1use std::cell::RefCell;
2use std::mem;
3
4use crate::ast;
5use crate::ast::Elem::*;
6use crate::ast::*;
7use crate::builder::Builder;
8use crate::error::{ParseError, ParseErrorAndPos};
9
10use crate::interner::*;
11
12use crate::lexer::position::{Position, Span};
13use crate::lexer::reader::Reader;
14use crate::lexer::token::*;
15use crate::lexer::File as LexerFile;
16use crate::lexer::*;
17
18pub struct Parser<'a> {
19 lexer: Lexer,
20 token: Token,
21 id_generator: &'a NodeIdGenerator,
22 interner: &'a mut Interner,
23 ast: &'a mut Ast,
24 param_idx: u32,
25 in_class_or_module: bool,
26 parse_struct_lit: bool,
27 last_end: Option<u32>,
28}
29
30type ExprResult = Result<Box<Expr>, ParseErrorAndPos>;
31type StmtResult = Result<Box<Stmt>, ParseErrorAndPos>;
32type StmtOrExprResult = Result<StmtOrExpr, ParseErrorAndPos>;
33
34enum StmtOrExpr {
35 Stmt(Box<Stmt>),
36 Expr(Box<Expr>),
37}
38
39impl<'a> Parser<'a> {
40 pub fn new(
41 reader: Reader,
42 id_generator: &'a NodeIdGenerator,
43 ast: &'a mut Ast,
44 interner: &'a mut Interner,
45 ) -> Parser<'a> {
46 let token = Token::new(TokenKind::End, Position::new(1, 1), Span::invalid());
47 let lexer = Lexer::new(reader);
48
49 let parser = Parser {
50 lexer,
51 token,
52 id_generator,
53 interner,
54 param_idx: 0,
55 in_class_or_module: false,
56 parse_struct_lit: true,
57 ast,
58 last_end: Some(0),
59 };
60
61 parser
62 }
63
64 fn generate_id(&mut self) -> NodeId {
65 self.id_generator.next()
66 }
67
68 pub fn parse(mut self) -> Result<LexerFile, ParseErrorAndPos> {
69 self.init()?;
70 let mut elements = vec![];
71
72 while !self.token.is_eof() {
73 self.parse_top_level_element(&mut elements)?;
74 }
75
76 let file = self.lexer.file();
77
78 self.ast.files.push(ast::File {
79 path: file.name.clone(),
80 elements,
81 });
82
83 Ok(file)
84 }
85
86 fn init(&mut self) -> Result<(), ParseErrorAndPos> {
87 self.advance_token()?;
88
89 Ok(())
90 }
91
92 fn parse_top_level_element(
93 &mut self,
94 elements: &mut Vec<Elem>,
95 ) -> Result<(), ParseErrorAndPos> {
96 let modifiers = self.parse_annotations()?;
97
98 match self.token.kind {
99 TokenKind::Fun => {
100 self.restrict_modifiers(
101 &modifiers,
102 &[
103 Modifier::Internal,
104 Modifier::Optimize,
105 Modifier::Test,
106 Modifier::Cannon,
107 ],
108 )?;
109 let fct = self.parse_function(&modifiers)?;
110 elements.push(ElemFunction(fct));
111 }
112
113 TokenKind::Class => {
114 self.restrict_modifiers(
115 &modifiers,
116 &[
117 Modifier::Abstract,
118 Modifier::Open,
119 Modifier::Internal,
120 Modifier::Cannon,
121 ],
122 )?;
123 let class = self.parse_class(&modifiers)?;
124 elements.push(ElemClass(class));
125 }
126
127 TokenKind::Struct => {
128 self.ban_modifiers(&modifiers)?;
129 let struc = self.parse_struct()?;
130 elements.push(ElemStruct(struc))
131 }
132
133 TokenKind::Trait => {
134 self.ban_modifiers(&modifiers)?;
135 let xtrait = self.parse_trait()?;
136 elements.push(ElemTrait(xtrait));
137 }
138
139 TokenKind::Impl => {
140 self.ban_modifiers(&modifiers)?;
141 let ximpl = self.parse_impl()?;
142 elements.push(ElemImpl(ximpl));
143 }
144
145 TokenKind::Module => {
146 self.ban_modifiers(&modifiers)?;
147 let module = self.parse_module(&modifiers)?;
148 elements.push(ElemModule(module));
149 }
150
151 TokenKind::Let | TokenKind::Var => {
152 self.ban_modifiers(&modifiers)?;
153 self.parse_global(elements)?;
154 }
155
156 TokenKind::Const => {
157 self.ban_modifiers(&modifiers)?;
158 let xconst = self.parse_const()?;
159 elements.push(ElemConst(xconst));
160 }
161
162 TokenKind::Enum => {
163 self.ban_modifiers(&modifiers)?;
164 let xenum = self.parse_enum()?;
165 elements.push(ElemEnum(xenum));
166 }
167
168 _ => {
169 let msg = ParseError::ExpectedTopLevelElement(self.token.name());
170 return Err(ParseErrorAndPos::new(self.token.position, msg));
171 }
172 }
173
174 Ok(())
175 }
176
177 fn parse_enum(&mut self) -> Result<Enum, ParseErrorAndPos> {
178 let start = self.token.span.start();
179 let pos = self.expect_token(TokenKind::Enum)?.position;
180 let name = self.expect_identifier()?;
181
182 self.expect_token(TokenKind::LBrace)?;
183 let values = self.parse_comma_list(TokenKind::RBrace, |p| p.parse_identifier())?;
184 let span = self.span_from(start);
185
186 Ok(Enum {
187 id: self.generate_id(),
188 pos,
189 span,
190 name,
191 values,
192 })
193 }
194
195 fn parse_const(&mut self) -> Result<Const, ParseErrorAndPos> {
196 let start = self.token.span.start();
197 let pos = self.expect_token(TokenKind::Const)?.position;
198 let name = self.expect_identifier()?;
199 self.expect_token(TokenKind::Colon)?;
200 let ty = self.parse_type()?;
201 self.expect_token(TokenKind::Eq)?;
202 let expr = self.parse_expression()?;
203 self.expect_semicolon()?;
204 let span = self.span_from(start);
205
206 Ok(Const {
207 id: self.generate_id(),
208 pos,
209 span,
210 name,
211 data_type: ty,
212 expr,
213 })
214 }
215
216 fn parse_impl(&mut self) -> Result<Impl, ParseErrorAndPos> {
217 let start = self.token.span.start();
218 let pos = self.expect_token(TokenKind::Impl)?.position;
219 let type_params = self.parse_type_params()?;
220
221 let type_name = self.parse_type()?;
222
223 let (class_type, trait_type) = if self.token.is(TokenKind::For) {
224 self.advance_token()?;
225 let class_type = self.parse_type()?;
226
227 (class_type, Some(type_name))
228 } else {
229 (type_name, None)
230 };
231
232 self.expect_token(TokenKind::LBrace)?;
233
234 let mut methods = Vec::new();
235
236 while !self.token.is(TokenKind::RBrace) {
237 let modifiers = self.parse_annotations()?;
238 let mods = &[Modifier::Static, Modifier::Internal, Modifier::Cannon];
239 self.restrict_modifiers(&modifiers, mods)?;
240
241 methods.push(self.parse_function(&modifiers)?);
242 }
243
244 self.expect_token(TokenKind::RBrace)?;
245 let span = self.span_from(start);
246
247 Ok(Impl {
248 id: self.generate_id(),
249 pos,
250 span,
251 type_params,
252 trait_type,
253 class_type,
254 methods,
255 })
256 }
257
258 fn parse_global(&mut self, elements: &mut Vec<Elem>) -> Result<(), ParseErrorAndPos> {
259 let start = self.token.span.start();
260 let pos = self.token.position;
261 let reassignable = self.token.is(TokenKind::Var);
262
263 self.advance_token()?;
264 let name = self.expect_identifier()?;
265
266 self.expect_token(TokenKind::Colon)?;
267 let data_type = self.parse_type()?;
268
269 let expr = if self.token.is(TokenKind::Eq) {
270 self.advance_token()?;
271
272 Some(self.parse_expression()?)
273 } else {
274 None
275 };
276
277 self.expect_semicolon()?;
278 let span = self.span_from(start);
279
280 let global = Global {
281 id: self.generate_id(),
282 name,
283 pos,
284 span,
285 data_type,
286 reassignable,
287 expr,
288 };
289
290 elements.push(ElemGlobal(global));
291
292 Ok(())
293 }
294
295 fn parse_trait(&mut self) -> Result<Trait, ParseErrorAndPos> {
296 let start = self.token.span.start();
297 let pos = self.expect_token(TokenKind::Trait)?.position;
298 let ident = self.expect_identifier()?;
299
300 self.expect_token(TokenKind::LBrace)?;
301
302 let mut methods = Vec::new();
303
304 while !self.token.is(TokenKind::RBrace) {
305 let modifiers = self.parse_annotations()?;
306 let mods = &[Modifier::Static];
307 self.restrict_modifiers(&modifiers, mods)?;
308
309 methods.push(self.parse_function(&modifiers)?);
310 }
311
312 self.expect_token(TokenKind::RBrace)?;
313 let span = self.span_from(start);
314
315 Ok(Trait {
316 id: self.generate_id(),
317 name: ident,
318 pos,
319 span,
320 methods,
321 })
322 }
323
324 fn parse_struct(&mut self) -> Result<Struct, ParseErrorAndPos> {
325 let start = self.token.span.start();
326 let pos = self.expect_token(TokenKind::Struct)?.position;
327 let ident = self.expect_identifier()?;
328
329 self.expect_token(TokenKind::LBrace)?;
330 let fields = self.parse_comma_list(TokenKind::RBrace, |p| p.parse_struct_field())?;
331 let span = self.span_from(start);
332
333 Ok(Struct {
334 id: self.generate_id(),
335 name: ident,
336 pos,
337 span,
338 fields,
339 })
340 }
341
342 fn parse_struct_field(&mut self) -> Result<StructField, ParseErrorAndPos> {
343 let start = self.token.span.start();
344 let pos = self.token.position;
345 let ident = self.expect_identifier()?;
346
347 self.expect_token(TokenKind::Colon)?;
348 let ty = self.parse_type()?;
349 let span = self.span_from(start);
350
351 Ok(StructField {
352 id: self.generate_id(),
353 name: ident,
354 pos,
355 span,
356 data_type: ty,
357 })
358 }
359
360 fn parse_class(&mut self, modifiers: &Modifiers) -> Result<Class, ParseErrorAndPos> {
361 let start = self.token.span.start();
362 let has_open = modifiers.contains(Modifier::Open);
363 let internal = modifiers.contains(Modifier::Internal);
364 let is_abstract = modifiers.contains(Modifier::Abstract);
365
366 let pos = self.expect_token(TokenKind::Class)?.position;
367 let ident = self.expect_identifier()?;
368 let type_params = self.parse_type_params()?;
369
370 let mut cls = Class {
371 id: self.generate_id(),
372 name: ident,
373 pos,
374 span: Span::invalid(),
375 has_open,
376 internal,
377 is_abstract,
378 has_constructor: false,
379 parent_class: None,
380 constructor: None,
381 fields: Vec::new(),
382 methods: Vec::new(),
383 initializers: Vec::new(),
384 type_params,
385 };
386
387 self.in_class_or_module = true;
388 let ctor_params = self.parse_constructor(&mut cls)?;
389
390 let use_cannon = modifiers.contains(Modifier::Cannon);
391
392 cls.parent_class = self.parse_class_parent()?;
393
394 self.parse_class_body(&mut cls)?;
395 let span = self.span_from(start);
396
397 cls.constructor = Some(self.generate_constructor(&mut cls, ctor_params, use_cannon));
398 cls.span = span;
399 self.in_class_or_module = false;
400
401 Ok(cls)
402 }
403
404 fn parse_class_parent(&mut self) -> Result<Option<ParentClass>, ParseErrorAndPos> {
405 if self.token.is(TokenKind::Colon) {
406 self.advance_token()?;
407
408 let start = self.token.span.start();
409 let pos = self.token.position;
410 let name = self.expect_identifier()?;
411 let type_params = self.parse_class_parent_type_params()?;
412 let params = self.parse_parent_class_params()?;
413 let span = self.span_from(start);
414
415 Ok(Some(ParentClass::new(name, pos, span, type_params, params)))
416 } else {
417 Ok(None)
418 }
419 }
420
421 fn parse_class_parent_type_params(&mut self) -> Result<Vec<Type>, ParseErrorAndPos> {
422 let mut types = Vec::new();
423
424 if self.token.is(TokenKind::LBracket) {
425 self.advance_token()?;
426 types = self.parse_comma_list(TokenKind::RBracket, |p| p.parse_type())?;
427 }
428
429 Ok(types)
430 }
431
432 fn parse_module(&mut self, modifiers: &Modifiers) -> Result<Module, ParseErrorAndPos> {
433 let internal = modifiers.contains(Modifier::Internal);
434
435 let pos = self.expect_token(TokenKind::Module)?.position;
436 let ident = self.expect_identifier()?;
437 let mut module = Module {
438 id: self.generate_id(),
439 name: ident,
440 pos: pos,
441 parent_class: None,
442 internal: internal,
443 has_constructor: false,
444 constructor: None,
445 fields: Vec::new(),
446 methods: Vec::new(),
447 initializers: Vec::new(),
448 };
449
450 self.in_class_or_module = true;
451
452 module.parent_class = if self.token.is(TokenKind::Colon) {
453 self.advance_token()?;
454
455 let start = self.token.span.start();
456 let pos = self.token.position;
457 let name = self.expect_identifier()?;
458 let type_params = self.parse_class_parent_type_params()?;
459 let params = self.parse_parent_class_params()?;
460 let span = self.span_from(start);
461
462 Some(ParentClass::new(name, pos, span, type_params, params))
463 } else {
464 None
465 };
466
467 self.parse_module_body(&mut module)?;
468 self.in_class_or_module = false;
469
470 Ok(module)
471 }
472
473 fn parse_type_params(&mut self) -> Result<Option<Vec<TypeParam>>, ParseErrorAndPos> {
474 if self.token.is(TokenKind::LBracket) {
475 self.advance_token()?;
476 let params = self.parse_comma_list(TokenKind::RBracket, |p| p.parse_type_param())?;
477
478 Ok(Some(params))
479 } else {
480 Ok(None)
481 }
482 }
483
484 fn parse_type_param(&mut self) -> Result<TypeParam, ParseErrorAndPos> {
485 let start = self.token.span.start();
486 let pos = self.token.position;
487 let name = self.expect_identifier()?;
488
489 let bounds = if self.token.is(TokenKind::Colon) {
490 self.advance_token()?;
491
492 let mut bounds = Vec::new();
493
494 loop {
495 bounds.push(self.parse_type()?);
496
497 if self.token.is(TokenKind::Add) {
498 self.advance_token()?;
499 } else {
500 break;
501 }
502 }
503
504 bounds
505 } else {
506 Vec::new()
507 };
508
509 let span = self.span_from(start);
510
511 Ok(TypeParam {
512 name,
513 span,
514 pos,
515 bounds,
516 })
517 }
518
519 fn parse_parent_class_params(&mut self) -> Result<Vec<Box<Expr>>, ParseErrorAndPos> {
520 if !self.token.is(TokenKind::LParen) {
521 return Ok(Vec::new());
522 }
523
524 self.expect_token(TokenKind::LParen)?;
525
526 let params = self.parse_comma_list(TokenKind::RParen, |p| p.parse_expression())?;
527
528 Ok(params)
529 }
530
531 fn parse_constructor(
532 &mut self,
533 cls: &mut Class,
534 ) -> Result<Vec<ConstructorParam>, ParseErrorAndPos> {
535 if !self.token.is(TokenKind::LParen) {
536 return Ok(Vec::new());
537 }
538
539 self.expect_token(TokenKind::LParen)?;
540 cls.has_constructor = true;
541
542 let params =
543 self.parse_comma_list(TokenKind::RParen, |p| p.parse_constructor_param(cls))?;
544
545 Ok(params)
546 }
547
548 fn parse_constructor_param(
549 &mut self,
550 cls: &mut Class,
551 ) -> Result<ConstructorParam, ParseErrorAndPos> {
552 let start = self.token.span.start();
553 let field = self.token.is(TokenKind::Var) || self.token.is(TokenKind::Let);
554 let reassignable = self.token.is(TokenKind::Var);
555
556 if field {
558 self.advance_token()?;
559 }
560
561 let pos = self.token.position;
562 let name = self.expect_identifier()?;
563
564 self.expect_token(TokenKind::Colon)?;
565 let data_type = self.parse_type()?;
566
567 let span = self.span_from(start);
568
569 if field {
570 cls.fields.push(Field {
571 id: self.generate_id(),
572 name,
573 pos,
574 span,
575 data_type: data_type.clone(),
576 primary_ctor: true,
577 expr: None,
578 reassignable,
579 })
580 }
581
582 Ok(ConstructorParam {
583 name,
584 pos,
585 span,
586 data_type,
587 field,
588 reassignable,
589 })
590 }
591
592 fn parse_class_body(&mut self, cls: &mut Class) -> Result<(), ParseErrorAndPos> {
593 if !self.token.is(TokenKind::LBrace) {
594 return Ok(());
595 }
596
597 self.advance_token()?;
598
599 while !self.token.is(TokenKind::RBrace) {
600 let modifiers = self.parse_annotations()?;
601
602 match self.token.kind {
603 TokenKind::Fun => {
604 let mods = &[
605 Modifier::Abstract,
606 Modifier::Internal,
607 Modifier::Open,
608 Modifier::Override,
609 Modifier::Final,
610 Modifier::Pub,
611 Modifier::Static,
612 Modifier::Cannon,
613 ];
614 self.restrict_modifiers(&modifiers, mods)?;
615
616 let fct = self.parse_function(&modifiers)?;
617 cls.methods.push(fct);
618 }
619
620 TokenKind::Var | TokenKind::Let => {
621 self.ban_modifiers(&modifiers)?;
622
623 let field = self.parse_field()?;
624 cls.fields.push(field);
625 }
626
627 _ => {
628 let initializer = self.parse_statement()?;
629 cls.initializers.push(initializer);
630 }
631 }
632 }
633
634 self.advance_token()?;
635 Ok(())
636 }
637
638 fn parse_module_body(&mut self, module: &mut Module) -> Result<(), ParseErrorAndPos> {
639 if !self.token.is(TokenKind::LBrace) {
640 return Ok(());
641 }
642
643 self.advance_token()?;
644
645 while !self.token.is(TokenKind::RBrace) {
646 let modifiers = self.parse_annotations()?;
647
648 match self.token.kind {
649 TokenKind::Fun => {
650 let mods = &[
651 Modifier::Abstract,
652 Modifier::Internal,
653 Modifier::Open,
654 Modifier::Override,
655 Modifier::Final,
656 Modifier::Pub,
657 Modifier::Static,
658 ];
659 self.restrict_modifiers(&modifiers, mods)?;
660
661 let fct = self.parse_function(&modifiers)?;
662 module.methods.push(fct);
663 }
664
665 TokenKind::Var | TokenKind::Let => {
666 self.ban_modifiers(&modifiers)?;
667
668 let field = self.parse_field()?;
669 module.fields.push(field);
670 }
671
672 _ => {
673 let initializer = self.parse_statement()?;
674 module.initializers.push(initializer);
675 }
676 }
677 }
678
679 self.advance_token()?;
680 Ok(())
681 }
682
683 fn parse_annotations(&mut self) -> Result<Modifiers, ParseErrorAndPos> {
684 let mut modifiers = Modifiers::new();
685 loop {
686 if !self.token.is(TokenKind::At) {
687 break;
688 }
689 self.advance_token()?;
690 let ident = self.expect_identifier()?;
691 let modifier = match self.interner.str(ident).as_str() {
692 "abstract" => Modifier::Abstract,
693 "open" => Modifier::Open,
694 "override" => Modifier::Override,
695 "final" => Modifier::Final,
696 "internal" => Modifier::Internal,
697 "pub" => Modifier::Pub,
698 "static" => Modifier::Static,
699 "optimize" => Modifier::Optimize,
700 "test" => Modifier::Test,
701 "cannon" => Modifier::Cannon,
702 "optimize_immediately" => Modifier::OptimizeImmediately,
703 _ => {
704 return Err(ParseErrorAndPos::new(
705 self.token.position,
706 ParseError::UnknownAnnotation(self.token.to_string()),
707 ));
708 }
709 };
710
711 if modifiers.contains(modifier) {
712 return Err(ParseErrorAndPos::new(
713 self.token.position,
714 ParseError::RedundantAnnotation(self.token.name()),
715 ));
716 }
717
718 modifiers.add(modifier, self.token.position, self.token.span);
719 }
720
721 Ok(modifiers)
722 }
723
724 fn ban_modifiers(&mut self, modifiers: &Modifiers) -> Result<(), ParseErrorAndPos> {
725 self.restrict_modifiers(modifiers, &[])
726 }
727
728 fn restrict_modifiers(
729 &mut self,
730 modifiers: &Modifiers,
731 restrict: &[Modifier],
732 ) -> Result<(), ParseErrorAndPos> {
733 for modifier in modifiers.iter() {
734 if !restrict.contains(&modifier.value) {
735 return Err(ParseErrorAndPos::new(
736 modifier.pos,
737 ParseError::MisplacedAnnotation(modifier.value.name().into()),
738 ));
739 }
740 }
741
742 Ok(())
743 }
744
745 fn parse_field(&mut self) -> Result<Field, ParseErrorAndPos> {
746 let start = self.token.span.start();
747 let pos = self.token.position;
748 let reassignable = if self.token.is(TokenKind::Var) {
749 self.expect_token(TokenKind::Var)?;
750
751 true
752 } else {
753 self.expect_token(TokenKind::Let)?;
754
755 false
756 };
757
758 let name = self.expect_identifier()?;
759 self.expect_token(TokenKind::Colon)?;
760 let data_type = self.parse_type()?;
761
762 let expr = if self.token.is(TokenKind::Eq) {
763 self.expect_token(TokenKind::Eq)?;
764 Some(self.parse_expression()?)
765 } else {
766 None
767 };
768
769 self.expect_semicolon()?;
770 let span = self.span_from(start);
771
772 Ok(Field {
773 id: self.generate_id(),
774 name,
775 pos,
776 span,
777 data_type,
778 primary_ctor: false,
779 expr,
780 reassignable,
781 })
782 }
783
784 fn parse_function(&mut self, modifiers: &Modifiers) -> Result<Function, ParseErrorAndPos> {
785 let start = self.token.span.start();
786 let pos = self.expect_token(TokenKind::Fun)?.position;
787 let ident = self.expect_identifier()?;
788 let type_params = self.parse_type_params()?;
789 let params = self.parse_function_params()?;
790 let throws = self.parse_throws()?;
791 let return_type = self.parse_function_type()?;
792 let block = self.parse_function_block()?;
793 let span = self.span_from(start);
794
795 Ok(Function {
796 id: self.generate_id(),
797 name: ident,
798 pos,
799 span,
800 method: self.in_class_or_module,
801 has_open: modifiers.contains(Modifier::Open),
802 has_override: modifiers.contains(Modifier::Override),
803 has_final: modifiers.contains(Modifier::Final),
804 has_optimize: modifiers.contains(Modifier::Optimize),
805 has_optimize_immediately: modifiers.contains(Modifier::OptimizeImmediately),
806 is_pub: modifiers.contains(Modifier::Pub),
807 is_static: modifiers.contains(Modifier::Static),
808 internal: modifiers.contains(Modifier::Internal),
809 is_abstract: modifiers.contains(Modifier::Abstract),
810 is_constructor: false,
811 is_test: modifiers.contains(Modifier::Test),
812 use_cannon: modifiers.contains(Modifier::Cannon),
813 params,
814 throws,
815 return_type,
816 block,
817 type_params,
818 })
819 }
820
821 fn parse_throws(&mut self) -> Result<bool, ParseErrorAndPos> {
822 if self.token.is(TokenKind::Throws) {
823 self.advance_token()?;
824
825 return Ok(true);
826 }
827
828 Ok(false)
829 }
830
831 fn parse_function_params(&mut self) -> Result<Vec<Param>, ParseErrorAndPos> {
832 self.expect_token(TokenKind::LParen)?;
833 self.param_idx = 0;
834
835 let params = self.parse_comma_list(TokenKind::RParen, |p| {
836 p.param_idx += 1;
837
838 p.parse_function_param()
839 })?;
840
841 Ok(params)
842 }
843
844 fn parse_comma_list<F, R>(
845 &mut self,
846 stop: TokenKind,
847 mut parse: F,
848 ) -> Result<Vec<R>, ParseErrorAndPos>
849 where
850 F: FnMut(&mut Parser) -> Result<R, ParseErrorAndPos>,
851 {
852 let mut data = vec![];
853 let mut comma = true;
854
855 while !self.token.is(stop.clone()) && !self.token.is_eof() {
856 if !comma {
857 return Err(ParseErrorAndPos::new(
858 self.token.position,
859 ParseError::ExpectedToken(TokenKind::Comma.name().into(), self.token.name()),
860 ));
861 }
862
863 let entry = parse(self)?;
864 data.push(entry);
865
866 comma = self.token.is(TokenKind::Comma);
867 if comma {
868 self.advance_token()?;
869 }
870 }
871
872 self.expect_token(stop)?;
873
874 Ok(data)
875 }
876
877 fn parse_function_param(&mut self) -> Result<Param, ParseErrorAndPos> {
878 let start = self.token.span.start();
879 let pos = self.token.position;
880
881 let reassignable = if self.token.is(TokenKind::Var) {
882 self.advance_token()?;
883
884 true
885 } else {
886 false
887 };
888
889 let name = self.expect_identifier()?;
890
891 self.expect_token(TokenKind::Colon)?;
892 let data_type = self.parse_type()?;
893 let span = self.span_from(start);
894
895 Ok(Param {
896 id: self.generate_id(),
897 idx: self.param_idx - 1,
898 reassignable,
899 name,
900 pos,
901 span,
902 data_type,
903 })
904 }
905
906 fn parse_function_type(&mut self) -> Result<Option<Type>, ParseErrorAndPos> {
907 if self.token.is(TokenKind::Arrow) {
908 self.advance_token()?;
909 let ty = self.parse_type()?;
910
911 Ok(Some(ty))
912 } else {
913 Ok(None)
914 }
915 }
916
917 fn parse_function_block(&mut self) -> Result<Option<Box<ExprBlockType>>, ParseErrorAndPos> {
918 if self.token.is(TokenKind::Semicolon) {
919 self.advance_token()?;
920
921 Ok(None)
922 } else if self.token.is(TokenKind::Eq) {
923 let expr = self.parse_function_block_expression()?;
924
925 Ok(Some(expr))
926 } else {
927 let block = self.parse_block()?;
928
929 if let Expr::ExprBlock(block_type) = *block {
930 Ok(Some(Box::new(block_type)))
931 } else {
932 unreachable!()
933 }
934 }
935 }
936
937 fn parse_function_block_expression(&mut self) -> Result<Box<ExprBlockType>, ParseErrorAndPos> {
938 self.expect_token(TokenKind::Eq)?;
939
940 match self.token.kind {
941 TokenKind::Throw => {
942 let stmt = self.parse_throw()?;
943 Ok(Box::new(ExprBlockType {
944 id: self.generate_id(),
945 pos: stmt.pos(),
946 span: stmt.span(),
947 stmts: vec![stmt],
948 expr: None,
949 }))
950 }
951
952 TokenKind::Return => {
953 let stmt = self.parse_return()?;
954 Ok(Box::new(ExprBlockType {
955 id: self.generate_id(),
956 pos: stmt.pos(),
957 span: stmt.span(),
958 stmts: vec![stmt],
959 expr: None,
960 }))
961 }
962
963 _ => {
964 let expr = self.parse_expression()?;
965 self.expect_token(TokenKind::Semicolon)?;
966 Ok(Box::new(ExprBlockType {
967 id: self.generate_id(),
968 pos: expr.pos(),
969 span: expr.span(),
970 stmts: Vec::new(),
971 expr: Some(expr),
972 }))
973 }
974 }
975 }
976
977 fn parse_type(&mut self) -> Result<Type, ParseErrorAndPos> {
978 match self.token.kind {
979 TokenKind::CapitalThis => {
980 let pos = self.token.position;
981 let span = self.token.span;
982 self.advance_token()?;
983 Ok(Type::create_self(self.generate_id(), pos, span))
984 }
985
986 TokenKind::Identifier(_) => {
987 let pos = self.token.position;
988 let start = self.token.span.start();
989 let name = self.expect_identifier()?;
990
991 let params = if self.token.is(TokenKind::LBracket) {
992 self.advance_token()?;
993 self.parse_comma_list(TokenKind::RBracket, |p| Ok(Box::new(p.parse_type()?)))?
994 } else {
995 Vec::new()
996 };
997
998 let span = self.span_from(start);
999 Ok(Type::create_basic(
1000 self.generate_id(),
1001 pos,
1002 span,
1003 name,
1004 params,
1005 ))
1006 }
1007
1008 TokenKind::LParen => {
1009 let start = self.token.span.start();
1010 let token = self.advance_token()?;
1011 let subtypes = self.parse_comma_list(TokenKind::RParen, |p| {
1012 let ty = p.parse_type()?;
1013
1014 Ok(Box::new(ty))
1015 })?;
1016
1017 if self.token.is(TokenKind::Arrow) {
1018 self.advance_token()?;
1019 let ret = Box::new(self.parse_type()?);
1020 let span = self.span_from(start);
1021
1022 Ok(Type::create_fct(
1023 self.generate_id(),
1024 token.position,
1025 span,
1026 subtypes,
1027 ret,
1028 ))
1029 } else {
1030 let span = self.span_from(start);
1031 Ok(Type::create_tuple(
1032 self.generate_id(),
1033 token.position,
1034 span,
1035 subtypes,
1036 ))
1037 }
1038 }
1039
1040 _ => Err(ParseErrorAndPos::new(
1041 self.token.position,
1042 ParseError::ExpectedType(self.token.name()),
1043 )),
1044 }
1045 }
1046
1047 fn parse_statement(&mut self) -> StmtResult {
1048 let stmt_or_expr = self.parse_statement_or_expression()?;
1049
1050 match stmt_or_expr {
1051 StmtOrExpr::Stmt(stmt) => Ok(stmt),
1052 StmtOrExpr::Expr(expr) => {
1053 if expr.needs_semicolon() {
1054 Err(self.expect_semicolon().unwrap_err())
1055 } else {
1056 Ok(Box::new(Stmt::create_expr(
1057 self.generate_id(),
1058 expr.pos(),
1059 expr.span(),
1060 expr,
1061 )))
1062 }
1063 }
1064 }
1065 }
1066
1067 fn parse_throw(&mut self) -> StmtResult {
1068 let start = self.token.span.start();
1069 let pos = self.expect_token(TokenKind::Throw)?.position;
1070 let expr = self.parse_expression()?;
1071 self.expect_semicolon()?;
1072 let span = self.span_from(start);
1073
1074 Ok(Box::new(Stmt::create_throw(
1075 self.generate_id(),
1076 pos,
1077 span,
1078 expr,
1079 )))
1080 }
1081
1082 fn parse_defer(&mut self) -> StmtResult {
1083 let start = self.token.span.start();
1084 let pos = self.expect_token(TokenKind::Defer)?.position;
1085 let expr = self.parse_expression()?;
1086 self.expect_semicolon()?;
1087 let span = self.span_from(start);
1088
1089 Ok(Box::new(Stmt::create_defer(
1090 self.generate_id(),
1091 pos,
1092 span,
1093 expr,
1094 )))
1095 }
1096
1097 fn parse_do(&mut self) -> StmtResult {
1098 let start = self.token.span.start();
1099 let pos = self.expect_token(TokenKind::Do)?.position;
1100 let try_block = self.parse_block_stmt()?;
1101 let mut catch_blocks = Vec::new();
1102
1103 while self.token.is(TokenKind::Catch) {
1104 catch_blocks.push(self.parse_catch()?);
1105 }
1106
1107 let finally_block = if self.token.is(TokenKind::Finally) {
1108 Some(self.parse_finally()?)
1109 } else {
1110 None
1111 };
1112
1113 let span = self.span_from(start);
1114
1115 Ok(Box::new(Stmt::create_do(
1116 self.generate_id(),
1117 pos,
1118 span,
1119 try_block,
1120 catch_blocks,
1121 finally_block,
1122 )))
1123 }
1124
1125 fn parse_catch(&mut self) -> Result<CatchBlock, ParseErrorAndPos> {
1126 let id = self.generate_id();
1127 let start = self.token.span.start();
1128 let pos = self.expect_token(TokenKind::Catch)?.position;
1129 let name = self.expect_identifier()?;
1130 self.expect_token(TokenKind::Colon)?;
1131 let data_type = self.parse_type()?;
1132 let block = self.parse_block_stmt()?;
1133 let span = self.span_from(start);
1134
1135 Ok(CatchBlock::new(id, name, pos, span, data_type, block))
1136 }
1137
1138 fn parse_finally(&mut self) -> Result<FinallyBlock, ParseErrorAndPos> {
1139 self.expect_token(TokenKind::Finally)?;
1140 let block = self.parse_block_stmt()?;
1141
1142 Ok(FinallyBlock::new(block))
1143 }
1144
1145 fn parse_var(&mut self) -> StmtResult {
1146 let start = self.token.span.start();
1147 let reassignable = if self.token.is(TokenKind::Let) {
1148 false
1149 } else if self.token.is(TokenKind::Var) {
1150 true
1151 } else {
1152 panic!("let or var expected")
1153 };
1154
1155 let pos = self.advance_token()?.position;
1156 let ident = self.expect_identifier()?;
1157 let data_type = self.parse_var_type()?;
1158 let expr = self.parse_var_assignment()?;
1159
1160 self.expect_semicolon()?;
1161 let span = self.span_from(start);
1162
1163 Ok(Box::new(Stmt::create_var(
1164 self.generate_id(),
1165 pos,
1166 span,
1167 ident,
1168 reassignable,
1169 data_type,
1170 expr,
1171 )))
1172 }
1173
1174 fn parse_var_type(&mut self) -> Result<Option<Type>, ParseErrorAndPos> {
1175 if self.token.is(TokenKind::Colon) {
1176 self.advance_token()?;
1177
1178 Ok(Some(self.parse_type()?))
1179 } else {
1180 Ok(None)
1181 }
1182 }
1183
1184 fn parse_var_assignment(&mut self) -> Result<Option<Box<Expr>>, ParseErrorAndPos> {
1185 if self.token.is(TokenKind::Eq) {
1186 self.expect_token(TokenKind::Eq)?;
1187 let expr = self.parse_expression()?;
1188
1189 Ok(Some(expr))
1190 } else {
1191 Ok(None)
1192 }
1193 }
1194
1195 fn parse_block_stmt(&mut self) -> StmtResult {
1196 let block = self.parse_block()?;
1197 Ok(Box::new(Stmt::create_expr(
1198 self.generate_id(),
1199 block.pos(),
1200 block.span(),
1201 block,
1202 )))
1203 }
1204
1205 fn parse_block(&mut self) -> ExprResult {
1206 let start = self.token.span.start();
1207 let pos = self.expect_token(TokenKind::LBrace)?.position;
1208 let mut stmts = vec![];
1209 let mut expr = None;
1210
1211 while !self.token.is(TokenKind::RBrace) && !self.token.is_eof() {
1212 let stmt_or_expr = self.parse_statement_or_expression()?;
1213
1214 match stmt_or_expr {
1215 StmtOrExpr::Stmt(stmt) => stmts.push(stmt),
1216 StmtOrExpr::Expr(curr_expr) => {
1217 if curr_expr.needs_semicolon() {
1218 expr = Some(curr_expr);
1219 break;
1220 } else if !self.token.is(TokenKind::RBrace) {
1221 stmts.push(Box::new(Stmt::create_expr(
1222 self.generate_id(),
1223 curr_expr.pos(),
1224 curr_expr.span(),
1225 curr_expr,
1226 )));
1227 } else {
1228 expr = Some(curr_expr);
1229 }
1230 }
1231 }
1232 }
1233
1234 self.expect_token(TokenKind::RBrace)?;
1235 let span = self.span_from(start);
1236
1237 Ok(Box::new(Expr::create_block(
1238 self.generate_id(),
1239 pos,
1240 span,
1241 stmts,
1242 expr,
1243 )))
1244 }
1245
1246 fn parse_statement_or_expression(&mut self) -> StmtOrExprResult {
1247 match self.token.kind {
1248 TokenKind::Let | TokenKind::Var => Ok(StmtOrExpr::Stmt(self.parse_var()?)),
1249 TokenKind::While => Ok(StmtOrExpr::Stmt(self.parse_while()?)),
1250 TokenKind::Loop => Ok(StmtOrExpr::Stmt(self.parse_loop()?)),
1251 TokenKind::Break => Ok(StmtOrExpr::Stmt(self.parse_break()?)),
1252 TokenKind::Continue => Ok(StmtOrExpr::Stmt(self.parse_continue()?)),
1253 TokenKind::Return => Ok(StmtOrExpr::Stmt(self.parse_return()?)),
1254 TokenKind::Else => Err(ParseErrorAndPos::new(
1255 self.token.position,
1256 ParseError::MisplacedElse,
1257 )),
1258 TokenKind::Throw => Ok(StmtOrExpr::Stmt(self.parse_throw()?)),
1259 TokenKind::Defer => Ok(StmtOrExpr::Stmt(self.parse_defer()?)),
1260 TokenKind::Do => Ok(StmtOrExpr::Stmt(self.parse_do()?)),
1261 TokenKind::For => Ok(StmtOrExpr::Stmt(self.parse_for()?)),
1262 _ => {
1263 let expr = self.parse_expression()?;
1264
1265 if self.token.is(TokenKind::Semicolon) {
1266 self.expect_token(TokenKind::Semicolon)?;
1267 let span = self.span_from(expr.span().start());
1268
1269 Ok(StmtOrExpr::Stmt(Box::new(Stmt::create_expr(
1270 self.generate_id(),
1271 expr.pos(),
1272 span,
1273 expr,
1274 ))))
1275 } else {
1276 Ok(StmtOrExpr::Expr(expr))
1277 }
1278 }
1279 }
1280 }
1281
1282 fn parse_if(&mut self) -> ExprResult {
1283 let start = self.token.span.start();
1284 let pos = self.expect_token(TokenKind::If)?.position;
1285
1286 let cond = self.parse_expression_no_struct_lit()?;
1287
1288 let then_block = self.parse_block()?;
1289
1290 let else_block = if self.token.is(TokenKind::Else) {
1291 self.advance_token()?;
1292
1293 if self.token.is(TokenKind::If) {
1294 Some(self.parse_if()?)
1295 } else {
1296 Some(self.parse_block()?)
1297 }
1298 } else {
1299 None
1300 };
1301
1302 let span = self.span_from(start);
1303
1304 Ok(Box::new(Expr::create_if(
1305 self.generate_id(),
1306 pos,
1307 span,
1308 cond,
1309 then_block,
1310 else_block,
1311 )))
1312 }
1313
1314 fn parse_for(&mut self) -> StmtResult {
1315 let start = self.token.span.start();
1316 let pos = self.expect_token(TokenKind::For)?.position;
1317 let name = self.expect_identifier()?;
1318 self.expect_token(TokenKind::In)?;
1319 let expr = self.parse_expression_no_struct_lit()?;
1320 let block = self.parse_block_stmt()?;
1321 let span = self.span_from(start);
1322
1323 Ok(Box::new(Stmt::create_for(
1324 self.generate_id(),
1325 pos,
1326 span,
1327 name,
1328 expr,
1329 block,
1330 )))
1331 }
1332
1333 fn parse_while(&mut self) -> StmtResult {
1334 let start = self.token.span.start();
1335 let pos = self.expect_token(TokenKind::While)?.position;
1336 let expr = self.parse_expression_no_struct_lit()?;
1337 let block = self.parse_block_stmt()?;
1338 let span = self.span_from(start);
1339
1340 Ok(Box::new(Stmt::create_while(
1341 self.generate_id(),
1342 pos,
1343 span,
1344 expr,
1345 block,
1346 )))
1347 }
1348
1349 fn parse_loop(&mut self) -> StmtResult {
1350 let start = self.token.span.start();
1351 let pos = self.expect_token(TokenKind::Loop)?.position;
1352 let block = self.parse_block_stmt()?;
1353 let span = self.span_from(start);
1354
1355 Ok(Box::new(Stmt::create_loop(
1356 self.generate_id(),
1357 pos,
1358 span,
1359 block,
1360 )))
1361 }
1362
1363 fn parse_break(&mut self) -> StmtResult {
1364 let start = self.token.span.start();
1365 let pos = self.expect_token(TokenKind::Break)?.position;
1366 self.expect_semicolon()?;
1367 let span = self.span_from(start);
1368
1369 Ok(Box::new(Stmt::create_break(self.generate_id(), pos, span)))
1370 }
1371
1372 fn parse_continue(&mut self) -> StmtResult {
1373 let start = self.token.span.start();
1374 let pos = self.expect_token(TokenKind::Continue)?.position;
1375 self.expect_semicolon()?;
1376 let span = self.span_from(start);
1377
1378 Ok(Box::new(Stmt::create_continue(
1379 self.generate_id(),
1380 pos,
1381 span,
1382 )))
1383 }
1384
1385 fn parse_return(&mut self) -> StmtResult {
1386 let start = self.token.span.start();
1387 let pos = self.expect_token(TokenKind::Return)?.position;
1388 let expr = if self.token.is(TokenKind::Semicolon) {
1389 None
1390 } else {
1391 let expr = self.parse_expression()?;
1392 Some(expr)
1393 };
1394
1395 self.expect_semicolon()?;
1396 let span = self.span_from(start);
1397
1398 Ok(Box::new(Stmt::create_return(
1399 self.generate_id(),
1400 pos,
1401 span,
1402 expr,
1403 )))
1404 }
1405
1406 fn parse_expression(&mut self) -> ExprResult {
1407 self.parse_expression_struct_lit(true)
1408 }
1409
1410 fn parse_expression_no_struct_lit(&mut self) -> ExprResult {
1411 self.parse_expression_struct_lit(false)
1412 }
1413
1414 fn parse_expression_struct_lit(&mut self, struct_lit: bool) -> ExprResult {
1415 let old = self.parse_struct_lit;
1416 self.parse_struct_lit = struct_lit;
1417
1418 let result = match self.token.kind {
1419 TokenKind::LBrace => self.parse_block(),
1420 TokenKind::If => self.parse_if(),
1421 _ => self.parse_binary(0),
1422 };
1423
1424 self.parse_struct_lit = old;
1425
1426 result
1427 }
1428
1429 fn parse_binary(&mut self, precedence: u32) -> ExprResult {
1430 let start = self.token.span.start();
1431 let mut left = self.parse_unary()?;
1432
1433 loop {
1434 let right_precedence = match self.token.kind {
1435 TokenKind::Or => 1,
1436 TokenKind::And => 2,
1437 TokenKind::Eq | TokenKind::AddEq => 3,
1438 TokenKind::EqEq
1439 | TokenKind::Ne
1440 | TokenKind::Lt
1441 | TokenKind::Le
1442 | TokenKind::Gt
1443 | TokenKind::Ge => 4,
1444 TokenKind::EqEqEq | TokenKind::NeEqEq => 5,
1445 TokenKind::BitOr | TokenKind::BitAnd | TokenKind::Caret => 6,
1446 TokenKind::LtLt | TokenKind::GtGt | TokenKind::GtGtGt => 7,
1447 TokenKind::Add | TokenKind::Sub => 8,
1448 TokenKind::Mul | TokenKind::Div | TokenKind::Mod => 9,
1449 TokenKind::Is | TokenKind::As => 10,
1450 _ => {
1451 return Ok(left);
1452 }
1453 };
1454
1455 if precedence >= right_precedence {
1456 return Ok(left);
1457 }
1458
1459 let tok = self.advance_token()?;
1460
1461 left = match tok.kind {
1462 TokenKind::Is | TokenKind::As => {
1463 let is = tok.is(TokenKind::Is);
1464
1465 let right = Box::new(self.parse_type()?);
1466 let span = self.span_from(start);
1467 let expr =
1468 Expr::create_conv(self.generate_id(), tok.position, span, left, right, is);
1469
1470 Box::new(expr)
1471 }
1472
1473 _ => {
1474 let right = self.parse_binary(right_precedence)?;
1475 self.create_binary(tok, start, left, right)
1476 }
1477 };
1478 }
1479 }
1480
1481 fn parse_unary(&mut self) -> ExprResult {
1482 match self.token.kind {
1483 TokenKind::Add | TokenKind::Sub | TokenKind::Not => {
1484 let start = self.token.span.start();
1485 let tok = self.advance_token()?;
1486 let op = match tok.kind {
1487 TokenKind::Add => UnOp::Plus,
1488 TokenKind::Sub => UnOp::Neg,
1489 TokenKind::Not => UnOp::Not,
1490 _ => unreachable!(),
1491 };
1492
1493 let expr = self.parse_primary()?;
1494 let span = self.span_from(start);
1495 Ok(Box::new(Expr::create_un(
1496 self.generate_id(),
1497 tok.position,
1498 span,
1499 op,
1500 expr,
1501 )))
1502 }
1503
1504 _ => self.parse_primary(),
1505 }
1506 }
1507
1508 fn parse_primary(&mut self) -> ExprResult {
1509 let start = self.token.span.start();
1510 let mut left = self.parse_factor()?;
1511
1512 loop {
1513 left = match self.token.kind {
1514 TokenKind::Dot => {
1515 let tok = self.advance_token()?;
1516 let rhs = self.parse_factor()?;
1517 let span = self.span_from(start);
1518
1519 Box::new(Expr::create_dot(
1520 self.generate_id(),
1521 tok.position,
1522 span,
1523 left,
1524 rhs,
1525 ))
1526 }
1527
1528 TokenKind::LParen => {
1529 let tok = self.advance_token()?;
1530 let args =
1531 self.parse_comma_list(TokenKind::RParen, |p| p.parse_expression())?;
1532 let span = self.span_from(start);
1533
1534 Box::new(Expr::create_call(
1535 self.generate_id(),
1536 tok.position,
1537 span,
1538 left,
1539 args,
1540 ))
1541 }
1542
1543 TokenKind::LBracket => {
1544 let tok = self.advance_token()?;
1545 let types = self.parse_comma_list(TokenKind::RBracket, |p| p.parse_type())?;
1546 let span = self.span_from(start);
1547
1548 Box::new(Expr::create_type_param(
1549 self.generate_id(),
1550 tok.position,
1551 span,
1552 left,
1553 types,
1554 ))
1555 }
1556
1557 TokenKind::Sep => {
1558 let tok = self.advance_token()?;
1559 let rhs = self.parse_factor()?;
1560 let span = self.span_from(start);
1561
1562 Box::new(Expr::create_path(
1563 self.generate_id(),
1564 tok.position,
1565 span,
1566 left,
1567 rhs,
1568 ))
1569 }
1570
1571 _ => {
1572 return Ok(left);
1573 }
1574 }
1575 }
1576 }
1577
1578 fn create_binary(
1579 &mut self,
1580 tok: Token,
1581 start: u32,
1582 left: Box<Expr>,
1583 right: Box<Expr>,
1584 ) -> Box<Expr> {
1585 let op = match tok.kind {
1586 TokenKind::Eq => BinOp::Assign,
1587 TokenKind::Or => BinOp::Or,
1588 TokenKind::And => BinOp::And,
1589 TokenKind::EqEq => BinOp::Cmp(CmpOp::Eq),
1590 TokenKind::Ne => BinOp::Cmp(CmpOp::Ne),
1591 TokenKind::Lt => BinOp::Cmp(CmpOp::Lt),
1592 TokenKind::Le => BinOp::Cmp(CmpOp::Le),
1593 TokenKind::Gt => BinOp::Cmp(CmpOp::Gt),
1594 TokenKind::Ge => BinOp::Cmp(CmpOp::Ge),
1595 TokenKind::EqEqEq => BinOp::Cmp(CmpOp::Is),
1596 TokenKind::NeEqEq => BinOp::Cmp(CmpOp::IsNot),
1597 TokenKind::BitOr => BinOp::BitOr,
1598 TokenKind::BitAnd => BinOp::BitAnd,
1599 TokenKind::Caret => BinOp::BitXor,
1600 TokenKind::Add => BinOp::Add,
1601 TokenKind::Sub => BinOp::Sub,
1602 TokenKind::Mul => BinOp::Mul,
1603 TokenKind::Div => BinOp::Div,
1604 TokenKind::Mod => BinOp::Mod,
1605 TokenKind::LtLt => BinOp::ShiftL,
1606 TokenKind::GtGt => BinOp::ArithShiftR,
1607 TokenKind::GtGtGt => BinOp::LogicalShiftR,
1608 _ => panic!("unimplemented token {:?}", tok),
1609 };
1610
1611 let span = self.span_from(start);
1612
1613 Box::new(Expr::create_bin(
1614 self.generate_id(),
1615 tok.position,
1616 span,
1617 op,
1618 left,
1619 right,
1620 ))
1621 }
1622
1623 fn parse_factor(&mut self) -> ExprResult {
1624 match self.token.kind {
1625 TokenKind::LParen => self.parse_parentheses(),
1626 TokenKind::LBrace => self.parse_block(),
1627 TokenKind::If => self.parse_if(),
1628 TokenKind::LitChar(_) => self.parse_lit_char(),
1629 TokenKind::LitInt(_, _, _) => self.parse_lit_int(),
1630 TokenKind::LitFloat(_, _) => self.parse_lit_float(),
1631 TokenKind::StringTail(_) | TokenKind::StringExpr(_) => self.parse_string(),
1632 TokenKind::Identifier(_) => self.parse_identifier(),
1633 TokenKind::True => self.parse_bool_literal(),
1634 TokenKind::False => self.parse_bool_literal(),
1635 TokenKind::Nil => self.parse_nil(),
1636 TokenKind::This => self.parse_this(),
1637 TokenKind::Super => self.parse_super(),
1638 TokenKind::Try => self.parse_try(),
1639 TokenKind::TryForce | TokenKind::TryOpt => self.parse_try_op(),
1640 TokenKind::BitOr | TokenKind::Or => self.parse_lambda(),
1641 _ => Err(ParseErrorAndPos::new(
1642 self.token.position,
1643 ParseError::ExpectedFactor(self.token.name().clone()),
1644 )),
1645 }
1646 }
1647
1648 fn parse_identifier(&mut self) -> ExprResult {
1649 let pos = self.token.position;
1650 let span = self.token.span;
1651 let name = self.expect_identifier()?;
1652
1653 Ok(Box::new(Expr::create_ident(
1654 self.generate_id(),
1655 pos,
1656 span,
1657 name,
1658 None,
1659 )))
1660 }
1661
1662 fn parse_parentheses(&mut self) -> ExprResult {
1663 let pos = self.token.position;
1664 let start = self.token.span.start();
1665 self.expect_token(TokenKind::LParen)?;
1666 let expr = self.parse_expression()?;
1667
1668 if self.token.kind == TokenKind::Comma {
1669 let mut values = vec![expr];
1670 let span;
1671
1672 loop {
1673 self.expect_token(TokenKind::Comma)?;
1674
1675 if self.token.kind == TokenKind::RParen {
1676 self.advance_token()?;
1677 span = self.span_from(start);
1678 break;
1679 }
1680
1681 let expr = self.parse_expression()?;
1682 values.push(expr);
1683
1684 if self.token.kind == TokenKind::RParen {
1685 self.advance_token()?;
1686 span = self.span_from(start);
1687 break;
1688 }
1689 }
1690
1691 Ok(Box::new(Expr::create_tuple(
1692 self.generate_id(),
1693 pos,
1694 span,
1695 values,
1696 )))
1697 } else {
1698 self.expect_token(TokenKind::RParen)?;
1699
1700 Ok(expr)
1701 }
1702 }
1703
1704 fn parse_try_op(&mut self) -> ExprResult {
1705 let start = self.token.span.start();
1706 let tok = self.advance_token()?;
1707 let exp = self.parse_expression()?;
1708
1709 let mode = if tok.is(TokenKind::TryForce) {
1710 TryMode::Force
1711 } else {
1712 TryMode::Opt
1713 };
1714
1715 let span = self.span_from(start);
1716
1717 Ok(Box::new(Expr::create_try(
1718 self.generate_id(),
1719 tok.position,
1720 span,
1721 exp,
1722 mode,
1723 )))
1724 }
1725
1726 fn parse_try(&mut self) -> ExprResult {
1727 let start = self.token.span.start();
1728 let pos = self.expect_token(TokenKind::Try)?.position;
1729 let exp = self.parse_expression()?;
1730
1731 let mode = if self.token.is(TokenKind::Else) {
1732 self.advance_token()?;
1733 let alt_exp = self.parse_expression()?;
1734
1735 TryMode::Else(alt_exp)
1736 } else {
1737 TryMode::Normal
1738 };
1739
1740 let span = self.span_from(start);
1741
1742 Ok(Box::new(Expr::create_try(
1743 self.generate_id(),
1744 pos,
1745 span,
1746 exp,
1747 mode,
1748 )))
1749 }
1750
1751 fn parse_lit_char(&mut self) -> ExprResult {
1752 let span = self.token.span;
1753 let tok = self.advance_token()?;
1754 let pos = tok.position;
1755
1756 if let TokenKind::LitChar(val) = tok.kind {
1757 Ok(Box::new(Expr::create_lit_char(
1758 self.generate_id(),
1759 pos,
1760 span,
1761 val,
1762 )))
1763 } else {
1764 unreachable!();
1765 }
1766 }
1767
1768 fn parse_lit_int(&mut self) -> ExprResult {
1769 let span = self.token.span;
1770 let tok = self.advance_token()?;
1771 let pos = tok.position;
1772
1773 if let TokenKind::LitInt(value, base, suffix) = tok.kind {
1774 let filtered = value.chars().filter(|&ch| ch != '_').collect::<String>();
1775 let parsed = u64::from_str_radix(&filtered, base.num());
1776
1777 match parsed {
1778 Ok(num) => {
1779 let expr =
1780 Expr::create_lit_int(self.generate_id(), pos, span, num, base, suffix);
1781 Ok(Box::new(expr))
1782 }
1783
1784 _ => {
1785 let bits = match suffix {
1786 IntSuffix::Byte => "byte",
1787 IntSuffix::Int => "int",
1788 IntSuffix::Long => "long",
1789 };
1790
1791 Err(ParseErrorAndPos::new(
1792 pos,
1793 ParseError::NumberOverflow(bits.into()),
1794 ))
1795 }
1796 }
1797 } else {
1798 unreachable!();
1799 }
1800 }
1801
1802 fn parse_lit_float(&mut self) -> ExprResult {
1803 let span = self.token.span;
1804 let tok = self.advance_token()?;
1805 let pos = tok.position;
1806
1807 if let TokenKind::LitFloat(value, suffix) = tok.kind {
1808 let filtered = value.chars().filter(|&ch| ch != '_').collect::<String>();
1809 let parsed = filtered.parse::<f64>();
1810
1811 if let Ok(num) = parsed {
1812 let expr = Expr::create_lit_float(self.generate_id(), pos, span, num, suffix);
1813 return Ok(Box::new(expr));
1814 }
1815 }
1816
1817 unreachable!()
1818 }
1819
1820 fn parse_string(&mut self) -> ExprResult {
1821 let span = self.token.span;
1822 let string = self.advance_token()?;
1823
1824 match string.kind {
1825 TokenKind::StringTail(value) => Ok(Box::new(Expr::create_lit_str(
1826 self.generate_id(),
1827 string.position,
1828 span,
1829 value,
1830 ))),
1831
1832 TokenKind::StringExpr(value) => {
1833 let start = self.token.span.start();
1834 let mut parts: Vec<Box<Expr>> = Vec::new();
1835 parts.push(Box::new(Expr::create_lit_str(
1836 self.generate_id(),
1837 string.position,
1838 span,
1839 value,
1840 )));
1841
1842 loop {
1843 let expr = self.parse_expression()?;
1844 parts.push(expr);
1845
1846 if !self.token.is(TokenKind::RBrace) {
1847 return Err(ParseErrorAndPos::new(
1848 self.token.position,
1849 ParseError::UnclosedStringTemplate,
1850 ));
1851 }
1852
1853 let token = self.lexer.read_string_continuation()?;
1854 self.advance_token_with(token);
1855
1856 let pos = self.token.position;
1857 let span = self.token.span;
1858
1859 let (value, finished) = match self.token.kind {
1860 TokenKind::StringTail(ref value) => (value.clone(), true),
1861 TokenKind::StringExpr(ref value) => (value.clone(), false),
1862 _ => unreachable!(),
1863 };
1864
1865 parts.push(Box::new(Expr::create_lit_str(
1866 self.generate_id(),
1867 pos,
1868 span,
1869 value,
1870 )));
1871
1872 self.advance_token()?;
1873
1874 if finished {
1875 break;
1876 }
1877 }
1878
1879 let span = self.span_from(start);
1880
1881 Ok(Box::new(Expr::create_template(
1882 self.generate_id(),
1883 string.position,
1884 span,
1885 parts,
1886 )))
1887 }
1888
1889 _ => unreachable!(),
1890 }
1891 }
1892
1893 fn parse_bool_literal(&mut self) -> ExprResult {
1894 let span = self.token.span;
1895 let tok = self.advance_token()?;
1896 let value = tok.is(TokenKind::True);
1897
1898 Ok(Box::new(Expr::create_lit_bool(
1899 self.generate_id(),
1900 tok.position,
1901 span,
1902 value,
1903 )))
1904 }
1905
1906 fn parse_this(&mut self) -> ExprResult {
1907 let span = self.token.span;
1908 let tok = self.advance_token()?;
1909
1910 Ok(Box::new(Expr::create_this(
1911 self.generate_id(),
1912 tok.position,
1913 span,
1914 )))
1915 }
1916
1917 fn parse_super(&mut self) -> ExprResult {
1918 let span = self.token.span;
1919 let tok = self.advance_token()?;
1920
1921 Ok(Box::new(Expr::create_super(
1922 self.generate_id(),
1923 tok.position,
1924 span,
1925 )))
1926 }
1927
1928 fn parse_nil(&mut self) -> ExprResult {
1929 let span = self.token.span;
1930 let tok = self.advance_token()?;
1931
1932 Ok(Box::new(Expr::create_nil(
1933 self.generate_id(),
1934 tok.position,
1935 span,
1936 )))
1937 }
1938
1939 fn parse_lambda(&mut self) -> ExprResult {
1940 let start = self.token.span.start();
1941 let tok = self.advance_token()?;
1942
1943 let params = if tok.kind == TokenKind::Or {
1944 Vec::new()
1946 } else {
1947 self.param_idx = 0;
1948 self.parse_comma_list(TokenKind::BitOr, |p| {
1949 p.param_idx += 1;
1950 p.parse_function_param()
1951 })?
1952 };
1953
1954 let ret = if self.token.is(TokenKind::Arrow) {
1955 self.advance_token()?;
1956 Some(Box::new(self.parse_type()?))
1957 } else {
1958 None
1959 };
1960
1961 let block = self.parse_block_stmt()?;
1962 let span = self.span_from(start);
1963
1964 Ok(Box::new(Expr::create_lambda(
1965 self.generate_id(),
1966 tok.position,
1967 span,
1968 params,
1969 ret,
1970 block,
1971 )))
1972 }
1973
1974 fn expect_identifier(&mut self) -> Result<Name, ParseErrorAndPos> {
1975 let tok = self.advance_token()?;
1976
1977 if let TokenKind::Identifier(ref value) = tok.kind {
1978 let interned = self.interner.intern(value);
1979
1980 Ok(interned)
1981 } else {
1982 Err(ParseErrorAndPos::new(
1983 tok.position,
1984 ParseError::ExpectedIdentifier(tok.name()),
1985 ))
1986 }
1987 }
1988
1989 fn expect_semicolon(&mut self) -> Result<Token, ParseErrorAndPos> {
1990 self.expect_token(TokenKind::Semicolon)
1991 }
1992
1993 fn expect_token(&mut self, kind: TokenKind) -> Result<Token, ParseErrorAndPos> {
1994 if self.token.kind == kind {
1995 let token = self.advance_token()?;
1996
1997 Ok(token)
1998 } else {
1999 Err(ParseErrorAndPos::new(
2000 self.token.position,
2001 ParseError::ExpectedToken(kind.name().into(), self.token.name()),
2002 ))
2003 }
2004 }
2005
2006 fn advance_token(&mut self) -> Result<Token, ParseErrorAndPos> {
2007 let token = self.lexer.read_token()?;
2008 Ok(self.advance_token_with(token))
2009 }
2010
2011 fn advance_token_with(&mut self, token: Token) -> Token {
2012 self.last_end = if self.token.span.is_valid() {
2013 Some(self.token.span.end())
2014 } else {
2015 None
2016 };
2017
2018 mem::replace(&mut self.token, token)
2019 }
2020
2021 fn span_from(&self, start: u32) -> Span {
2022 Span::new(start, self.last_end.unwrap() - start)
2023 }
2024
2025 fn generate_constructor(
2026 &mut self,
2027 cls: &mut Class,
2028 ctor_params: Vec<ConstructorParam>,
2029 use_cannon: bool,
2030 ) -> Function {
2031 let builder = Builder::new(self.id_generator);
2032 let mut block = builder.build_block();
2033
2034 if let Some(ref parent_class) = cls.parent_class {
2035 let expr = Expr::create_delegation(
2036 self.generate_id(),
2037 parent_class.pos,
2038 parent_class.span,
2039 parent_class.params.clone(),
2040 );
2041
2042 block.add_expr(Box::new(expr));
2043 }
2044
2045 for param in ctor_params.iter().filter(|param| param.field) {
2046 let this = builder.build_this();
2047 let lhs = builder.build_dot(this, builder.build_ident(param.name));
2048 let rhs = builder.build_ident(param.name);
2049 let ass = builder.build_assign(lhs, rhs);
2050
2051 block.add_expr(ass);
2052 }
2053
2054 for field in cls.fields.iter().filter(|field| field.expr.is_some()) {
2055 let this = builder.build_this();
2056 let lhs = builder.build_dot(this, builder.build_ident(field.name));
2057 let ass = builder.build_assign(lhs, field.expr.as_ref().unwrap().clone());
2058
2059 block.add_expr(ass);
2060 }
2061
2062 block.add_stmts(mem::replace(&mut cls.initializers, Vec::new()));
2063
2064 let mut fct = builder.build_fct(cls.name);
2065
2066 for field in &ctor_params {
2067 fct.add_param(field.name, field.data_type.clone());
2068 }
2069
2070 fct.is_method(true)
2071 .is_public(true)
2072 .use_cannon(use_cannon)
2073 .constructor(true)
2074 .block(block.build());
2075
2076 fct.build()
2077 }
2078}
2079
2080#[derive(Clone, Debug)]
2081struct Delegation {
2082 pub pos: Position,
2083 pub args: Vec<Box<Expr>>,
2084}
2085
2086#[derive(Debug)]
2087pub struct NodeIdGenerator {
2088 value: RefCell<usize>,
2089}
2090
2091impl NodeIdGenerator {
2092 pub fn new() -> NodeIdGenerator {
2093 NodeIdGenerator {
2094 value: RefCell::new(1),
2095 }
2096 }
2097
2098 pub fn next(&self) -> NodeId {
2099 let value = *self.value.borrow();
2100 *self.value.borrow_mut() += 1;
2101
2102 NodeId(value)
2103 }
2104}
2105
2106#[cfg(test)]
2107mod tests {
2108 use crate::ast::*;
2109 use crate::interner::*;
2110
2111 use crate::error::ParseError;
2112 use crate::lexer::position::Position;
2113 use crate::lexer::reader::Reader;
2114 use crate::parser::{NodeIdGenerator, Parser};
2115
2116 fn parse_expr(code: &'static str) -> (Box<Expr>, Interner) {
2117 let id_generator = NodeIdGenerator::new();
2118 let mut interner = Interner::new();
2119 let mut ast = Ast::new();
2120
2121 let expr = {
2122 let reader = Reader::from_string("<<code>>", code);
2123 let mut parser = Parser::new(reader, &id_generator, &mut ast, &mut interner);
2124 assert!(parser.init().is_ok(), true);
2125
2126 let result = parser.parse_expression();
2127
2128 if let Err(ref msg) = result {
2129 println!("error parsing: {:?}", msg);
2130 }
2131
2132 result.unwrap()
2133 };
2134
2135 (expr, interner)
2136 }
2137
2138 fn err_expr(code: &'static str, msg: ParseError, line: u32, col: u32) {
2139 let err = {
2140 let id_generator = NodeIdGenerator::new();
2141 let mut interner = Interner::new();
2142 let mut ast = Ast::new();
2143 let reader = Reader::from_string("<<code>>", code);
2144 let mut parser = Parser::new(reader, &id_generator, &mut ast, &mut interner);
2145
2146 assert!(parser.init().is_ok(), true);
2147 parser.parse_expression().unwrap_err()
2148 };
2149
2150 assert_eq!(msg, err.error);
2151 assert_eq!(line, err.pos.line);
2152 assert_eq!(col, err.pos.column);
2153 }
2154
2155 fn parse_stmt(code: &'static str) -> Box<Stmt> {
2156 let id_generator = NodeIdGenerator::new();
2157 let mut interner = Interner::new();
2158 let mut ast = Ast::new();
2159 let reader = Reader::from_string("<<code>>", code);
2160 let mut parser = Parser::new(reader, &id_generator, &mut ast, &mut interner);
2161 assert!(parser.init().is_ok(), true);
2162
2163 parser.parse_statement().unwrap()
2164 }
2165
2166 fn err_stmt(code: &'static str, msg: ParseError, line: u32, col: u32) {
2167 let err = {
2168 let id_generator = NodeIdGenerator::new();
2169 let mut interner = Interner::new();
2170 let mut ast = Ast::new();
2171 let reader = Reader::from_string("<<code>>", code);
2172 let mut parser = Parser::new(reader, &id_generator, &mut ast, &mut interner);
2173
2174 assert!(parser.init().is_ok(), true);
2175 parser.parse_statement().unwrap_err()
2176 };
2177
2178 assert_eq!(msg, err.error);
2179 assert_eq!(line, err.pos.line);
2180 assert_eq!(col, err.pos.column);
2181 }
2182
2183 fn parse_type(code: &'static str) -> (Type, Interner) {
2184 let mut interner = Interner::new();
2185 let ty = {
2186 let id_generator = NodeIdGenerator::new();
2187 let mut ast = Ast::new();
2188 let reader = Reader::from_string("<<code>>", code);
2189 let mut parser = Parser::new(reader, &id_generator, &mut ast, &mut interner);
2190 assert!(parser.init().is_ok(), true);
2191
2192 parser.parse_type().unwrap()
2193 };
2194
2195 (ty, interner)
2196 }
2197
2198 fn parse(code: &'static str) -> (Ast, Interner) {
2199 let id_generator = NodeIdGenerator::new();
2200 let mut interner = Interner::new();
2201 let mut ast = Ast::new();
2202
2203 let reader = Reader::from_string("<<code>>", code);
2204 Parser::new(reader, &id_generator, &mut ast, &mut interner)
2205 .parse()
2206 .unwrap();
2207
2208 (ast, interner)
2209 }
2210
2211 fn parse_err(code: &'static str, msg: ParseError, line: u32, col: u32) {
2212 let id_generator = NodeIdGenerator::new();
2213 let mut interner = Interner::new();
2214 let mut ast = Ast::new();
2215
2216 let reader = Reader::from_string("<<code>>", code);
2217 let err = Parser::new(reader, &id_generator, &mut ast, &mut interner)
2218 .parse()
2219 .unwrap_err();
2220
2221 assert_eq!(msg, err.error);
2222 assert_eq!(line, err.pos.line);
2223 assert_eq!(col, err.pos.column);
2224 }
2225
2226 #[test]
2227 fn parse_ident() {
2228 let (expr, interner) = parse_expr("a");
2229
2230 let ident = expr.to_ident().unwrap();
2231 assert_eq!("a", *interner.str(ident.name));
2232 }
2233
2234 #[test]
2235 fn parse_number() {
2236 let (expr, _) = parse_expr("10");
2237
2238 let lit = expr.to_lit_int().unwrap();
2239 assert_eq!(10, lit.value);
2240 }
2241
2242 #[test]
2243 fn parse_number_with_underscore() {
2244 let (expr, _) = parse_expr("1____0");
2245
2246 let lit = expr.to_lit_int().unwrap();
2247 assert_eq!(10, lit.value);
2248 }
2249
2250 #[test]
2251 fn parse_string() {
2252 let (expr, _) = parse_expr("\"abc\"");
2253
2254 let lit = expr.to_lit_str().unwrap();
2255 assert_eq!("abc", &lit.value);
2256 }
2257
2258 #[test]
2259 fn parse_true() {
2260 let (expr, _) = parse_expr("true");
2261
2262 let lit = expr.to_lit_bool().unwrap();
2263 assert_eq!(true, lit.value);
2264 }
2265
2266 #[test]
2267 fn parse_false() {
2268 let (expr, _) = parse_expr("true");
2269
2270 let lit = expr.to_lit_bool().unwrap();
2271 assert_eq!(true, lit.value);
2272 }
2273
2274 #[test]
2275 fn parse_field_access() {
2276 let (expr, interner) = parse_expr("obj.field");
2277 let dot = expr.to_dot().unwrap();
2278
2279 let ident = dot.lhs.to_ident().unwrap();
2280 assert_eq!("obj", *interner.str(ident.name));
2281
2282 let ident = dot.rhs.to_ident().unwrap();
2283 assert_eq!("field", *interner.str(ident.name));
2284 }
2285
2286 #[test]
2287 fn parse_field_negated() {
2288 let (expr, _) = parse_expr("-obj.field");
2289 assert!(expr.to_un().unwrap().opnd.is_dot());
2290 }
2291
2292 #[test]
2293 fn parse_field_non_ident() {
2294 let (expr, interner) = parse_expr("bar.12");
2295 let dot = expr.to_dot().unwrap();
2296
2297 let ident = dot.lhs.to_ident().unwrap();
2298 assert_eq!("bar", *interner.str(ident.name));
2299
2300 assert_eq!(12, dot.rhs.to_lit_int().unwrap().value);
2301 }
2302
2303 #[test]
2304 fn parse_self() {
2305 let (expr, _) = parse_expr("self");
2306
2307 assert!(expr.is_this());
2308 }
2309
2310 #[test]
2311 fn parse_nil() {
2312 let (expr, _) = parse_expr("nil");
2313
2314 assert!(expr.is_nil());
2315 }
2316
2317 #[test]
2318 fn parse_neg() {
2319 let (expr, _) = parse_expr("-1");
2320
2321 let un = expr.to_un().unwrap();
2322 assert_eq!(UnOp::Neg, un.op);
2323
2324 assert!(un.opnd.is_lit_int());
2325 }
2326
2327 #[test]
2328 fn parse_double_neg() {
2329 let (expr, _) = parse_expr("-(-3)");
2330
2331 let neg1 = expr.to_un().unwrap();
2332 assert_eq!(UnOp::Neg, neg1.op);
2333
2334 let neg2 = neg1.opnd.to_un().unwrap();
2335 assert_eq!(UnOp::Neg, neg2.op);
2336
2337 assert!(neg2.opnd.is_lit_int());
2338 }
2339
2340 #[test]
2341 fn parse_double_neg_without_parentheses() {
2342 err_expr("- -2", ParseError::ExpectedFactor("-".into()), 1, 3);
2343 }
2344
2345 #[test]
2346 fn parse_unary_plus() {
2347 let (expr, _) = parse_expr("+2");
2348
2349 let add = expr.to_un().unwrap();
2350 assert_eq!(UnOp::Plus, add.op);
2351
2352 assert!(add.opnd.is_lit_int());
2353 }
2354
2355 #[test]
2356 fn parse_double_unary_plus_without_parentheses() {
2357 err_expr("+ +4", ParseError::ExpectedFactor("+".into()), 1, 3);
2358 }
2359
2360 #[test]
2361 fn parse_double_unary_plus() {
2362 let (expr, _) = parse_expr("+(+9)");
2363
2364 let add1 = expr.to_un().unwrap();
2365 assert_eq!(UnOp::Plus, add1.op);
2366
2367 let add2 = add1.opnd.to_un().unwrap();
2368 assert_eq!(UnOp::Plus, add2.op);
2369 assert!(add2.opnd.is_lit_int());
2370 }
2371
2372 #[test]
2373 fn parse_mul() {
2374 let (expr, _) = parse_expr("6*3");
2375
2376 let mul = expr.to_bin().unwrap();
2377 assert_eq!(BinOp::Mul, mul.op);
2378 assert_eq!(6, mul.lhs.to_lit_int().unwrap().value);
2379 assert_eq!(3, mul.rhs.to_lit_int().unwrap().value);
2380 }
2381
2382 #[test]
2383 fn parse_multiple_muls() {
2384 let (expr, _) = parse_expr("6*3*4");
2385
2386 let mul1 = expr.to_bin().unwrap();
2387 assert_eq!(BinOp::Mul, mul1.op);
2388
2389 let mul2 = mul1.lhs.to_bin().unwrap();
2390 assert_eq!(BinOp::Mul, mul2.op);
2391 assert_eq!(6, mul2.lhs.to_lit_int().unwrap().value);
2392 assert_eq!(3, mul2.rhs.to_lit_int().unwrap().value);
2393
2394 assert_eq!(4, mul1.rhs.to_lit_int().unwrap().value);
2395 }
2396
2397 #[test]
2398 fn parse_div() {
2399 let (expr, _) = parse_expr("4/5");
2400
2401 let div = expr.to_bin().unwrap();
2402 assert_eq!(BinOp::Div, div.op);
2403 assert_eq!(4, div.lhs.to_lit_int().unwrap().value);
2404 assert_eq!(5, div.rhs.to_lit_int().unwrap().value);
2405 }
2406
2407 #[test]
2408 fn parse_mod() {
2409 let (expr, _) = parse_expr("2%15");
2410
2411 let div = expr.to_bin().unwrap();
2412 assert_eq!(BinOp::Mod, div.op);
2413 assert_eq!(2, div.lhs.to_lit_int().unwrap().value);
2414 assert_eq!(15, div.rhs.to_lit_int().unwrap().value);
2415 }
2416
2417 #[test]
2418 fn parse_add() {
2419 let (expr, _) = parse_expr("2+3");
2420
2421 let add = expr.to_bin().unwrap();
2422 assert_eq!(BinOp::Add, add.op);
2423 assert_eq!(2, add.lhs.to_lit_int().unwrap().value);
2424 assert_eq!(3, add.rhs.to_lit_int().unwrap().value);
2425 }
2426
2427 #[test]
2428 fn parse_add_left_associativity() {
2429 let (expr, _) = parse_expr("1+2+3");
2430
2431 let add = expr.to_bin().unwrap();
2432 assert_eq!(3, add.rhs.to_lit_int().unwrap().value);
2433
2434 let lhs = add.lhs.to_bin().unwrap();
2435 assert_eq!(1, lhs.lhs.to_lit_int().unwrap().value);
2436 assert_eq!(2, lhs.rhs.to_lit_int().unwrap().value);
2437 }
2438
2439 #[test]
2440 fn parse_add_right_associativity_via_parens() {
2441 let (expr, _) = parse_expr("1+(2+3)");
2442
2443 let add = expr.to_bin().unwrap();
2444 assert_eq!(1, add.lhs.to_lit_int().unwrap().value);
2445
2446 let rhs = add.rhs.to_bin().unwrap();
2447 assert_eq!(2, rhs.lhs.to_lit_int().unwrap().value);
2448 assert_eq!(3, rhs.rhs.to_lit_int().unwrap().value);
2449 }
2450
2451 #[test]
2452 fn parse_sub() {
2453 let (expr, _) = parse_expr("1-2");
2454
2455 let add = expr.to_bin().unwrap();
2456 assert_eq!(BinOp::Sub, add.op);
2457 assert_eq!(1, add.lhs.to_lit_int().unwrap().value);
2458 assert_eq!(2, add.rhs.to_lit_int().unwrap().value);
2459 }
2460
2461 #[test]
2462 fn parse_or() {
2463 let (expr, _) = parse_expr("1||2");
2464
2465 let add = expr.to_bin().unwrap();
2466 assert_eq!(BinOp::Or, add.op);
2467 assert_eq!(1, add.lhs.to_lit_int().unwrap().value);
2468 assert_eq!(2, add.rhs.to_lit_int().unwrap().value);
2469 }
2470
2471 #[test]
2472 fn parse_and() {
2473 let (expr, _) = parse_expr("1&&2");
2474
2475 let add = expr.to_bin().unwrap();
2476 assert_eq!(BinOp::And, add.op);
2477 assert_eq!(1, add.lhs.to_lit_int().unwrap().value);
2478 assert_eq!(2, add.rhs.to_lit_int().unwrap().value);
2479 }
2480
2481 #[test]
2482 fn parse_bit_or() {
2483 let (expr, _) = parse_expr("1|2");
2484
2485 let or = expr.to_bin().unwrap();
2486 assert_eq!(BinOp::BitOr, or.op);
2487 assert_eq!(1, or.lhs.to_lit_int().unwrap().value);
2488 assert_eq!(2, or.rhs.to_lit_int().unwrap().value);
2489 }
2490
2491 #[test]
2492 fn parse_bit_and() {
2493 let (expr, _) = parse_expr("1&2");
2494
2495 let and = expr.to_bin().unwrap();
2496 assert_eq!(BinOp::BitAnd, and.op);
2497 assert_eq!(1, and.lhs.to_lit_int().unwrap().value);
2498 assert_eq!(2, and.rhs.to_lit_int().unwrap().value);
2499 }
2500
2501 #[test]
2502 fn parse_bit_xor() {
2503 let (expr, _) = parse_expr("1^2");
2504
2505 let xor = expr.to_bin().unwrap();
2506 assert_eq!(BinOp::BitXor, xor.op);
2507 assert_eq!(1, xor.lhs.to_lit_int().unwrap().value);
2508 assert_eq!(2, xor.rhs.to_lit_int().unwrap().value);
2509 }
2510
2511 #[test]
2512 fn parse_lt() {
2513 let (expr, _) = parse_expr("1<2");
2514
2515 let cmp = expr.to_bin().unwrap();
2516 assert_eq!(BinOp::Cmp(CmpOp::Lt), cmp.op);
2517 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2518 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2519 }
2520
2521 #[test]
2522 fn parse_le() {
2523 let (expr, _) = parse_expr("1<=2");
2524
2525 let cmp = expr.to_bin().unwrap();
2526 assert_eq!(BinOp::Cmp(CmpOp::Le), cmp.op);
2527 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2528 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2529 }
2530
2531 #[test]
2532 fn parse_gt() {
2533 let (expr, _) = parse_expr("1>2");
2534
2535 let cmp = expr.to_bin().unwrap();
2536 assert_eq!(BinOp::Cmp(CmpOp::Gt), cmp.op);
2537 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2538 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2539 }
2540
2541 #[test]
2542 fn parse_ge() {
2543 let (expr, _) = parse_expr("1>=2");
2544
2545 let cmp = expr.to_bin().unwrap();
2546 assert_eq!(BinOp::Cmp(CmpOp::Ge), cmp.op);
2547 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2548 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2549 }
2550
2551 #[test]
2552 fn parse_eq() {
2553 let (expr, _) = parse_expr("1==2");
2554
2555 let cmp = expr.to_bin().unwrap();
2556 assert_eq!(BinOp::Cmp(CmpOp::Eq), cmp.op);
2557 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2558 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2559 }
2560
2561 #[test]
2562 fn parse_ne() {
2563 let (expr, _) = parse_expr("1!=2");
2564
2565 let cmp = expr.to_bin().unwrap();
2566 assert_eq!(BinOp::Cmp(CmpOp::Ne), cmp.op);
2567 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2568 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2569 }
2570
2571 #[test]
2572 fn parse_is_not() {
2573 let (expr, _) = parse_expr("1!==2");
2574
2575 let cmp = expr.to_bin().unwrap();
2576 assert_eq!(BinOp::Cmp(CmpOp::IsNot), cmp.op);
2577 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2578 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2579 }
2580
2581 #[test]
2582 fn parse_is() {
2583 let (expr, _) = parse_expr("1===2");
2584
2585 let cmp = expr.to_bin().unwrap();
2586 assert_eq!(BinOp::Cmp(CmpOp::Is), cmp.op);
2587 assert_eq!(1, cmp.lhs.to_lit_int().unwrap().value);
2588 assert_eq!(2, cmp.rhs.to_lit_int().unwrap().value);
2589 }
2590
2591 #[test]
2592 fn parse_assign() {
2593 let (expr, _) = parse_expr("a=4");
2594
2595 let assign = expr.to_bin().unwrap();
2596 assert!(assign.lhs.is_ident());
2597 assert_eq!(BinOp::Assign, assign.op);
2598 assert_eq!(4, assign.rhs.to_lit_int().unwrap().value);
2599 }
2600
2601 #[test]
2602 fn parse_shift_right() {
2603 let (expr, _) = parse_expr("a>>4");
2604
2605 let bin = expr.to_bin().unwrap();
2606 assert_eq!(BinOp::ArithShiftR, bin.op);
2607 }
2608
2609 #[test]
2610 fn parse_unsigned_shift_right() {
2611 let (expr, _) = parse_expr("a>>>4");
2612
2613 let bin = expr.to_bin().unwrap();
2614 assert_eq!(BinOp::LogicalShiftR, bin.op);
2615 }
2616
2617 #[test]
2618 fn parse_left() {
2619 let (expr, _) = parse_expr("a<<4");
2620
2621 let bin = expr.to_bin().unwrap();
2622 assert_eq!(BinOp::ShiftL, bin.op);
2623 }
2624
2625 #[test]
2626 fn parse_call_without_params() {
2627 let (expr, interner) = parse_expr("fname()");
2628
2629 let call = expr.to_call().unwrap();
2630 assert_eq!("fname", *interner.str(call.callee.to_ident().unwrap().name));
2631 assert_eq!(0, call.args.len());
2632 }
2633
2634 #[test]
2635 fn parse_call_with_params() {
2636 let (expr, interner) = parse_expr("fname2(1,2,3)");
2637
2638 let call = expr.to_call().unwrap();
2639 assert_eq!(
2640 "fname2",
2641 *interner.str(call.callee.to_ident().unwrap().name)
2642 );
2643 assert_eq!(3, call.args.len());
2644
2645 for i in 0..3 {
2646 let lit = call.args[i as usize].to_lit_int().unwrap();
2647 assert_eq!(i + 1, lit.value);
2648 }
2649 }
2650
2651 #[test]
2652 fn parse_function() {
2653 let (prog, interner) = parse("fun b() { }");
2654 let fct = prog.fct0();
2655
2656 assert_eq!("b", *interner.str(fct.name));
2657 assert_eq!(0, fct.params.len());
2658 assert!(fct.return_type.is_none());
2659 assert_eq!(Position::new(1, 1), fct.pos);
2660 }
2661
2662 #[test]
2663 fn parse_function_with_single_param() {
2664 let (p1, interner1) = parse("fun f(a:int) { }");
2665 let f1 = p1.fct0();
2666
2667 let (p2, interner2) = parse("fun f(a:int,) { }");
2668 let f2 = p2.fct0();
2669
2670 let p1 = &f1.params[0];
2671 let p2 = &f2.params[0];
2672
2673 assert_eq!(NodeId(2), p1.id);
2674 assert_eq!(NodeId(2), p2.id);
2675
2676 assert_eq!("a", *interner1.str(p1.name));
2677 assert_eq!("a", *interner2.str(p2.name));
2678
2679 assert_eq!("int", *interner1.str(p1.data_type.to_basic().unwrap().name));
2680 assert_eq!("int", *interner2.str(p2.data_type.to_basic().unwrap().name));
2681 }
2682
2683 #[test]
2684 fn parse_function_with_multiple_params() {
2685 let (p1, interner1) = parse("fun f(a:int, b:str) { }");
2686 let f1 = p1.fct0();
2687
2688 let (p2, interner2) = parse("fun f(a:int, b:str,) { }");
2689 let f2 = p2.fct0();
2690
2691 let p1a = &f1.params[0];
2692 let p1b = &f1.params[1];
2693 let p2a = &f2.params[0];
2694 let p2b = &f2.params[1];
2695
2696 assert_eq!("a", *interner1.str(p1a.name));
2697 assert_eq!("a", *interner2.str(p2a.name));
2698
2699 assert_eq!("b", *interner1.str(p1b.name));
2700 assert_eq!("b", *interner2.str(p2b.name));
2701
2702 assert_eq!(
2703 "int",
2704 *interner1.str(p1a.data_type.to_basic().unwrap().name)
2705 );
2706 assert_eq!(
2707 "int",
2708 *interner2.str(p2a.data_type.to_basic().unwrap().name)
2709 );
2710
2711 assert_eq!(
2712 "str",
2713 *interner1.str(p1b.data_type.to_basic().unwrap().name)
2714 );
2715 assert_eq!(
2716 "str",
2717 *interner2.str(p2b.data_type.to_basic().unwrap().name)
2718 );
2719 }
2720
2721 #[test]
2722 fn parse_let_without_type() {
2723 let stmt = parse_stmt("let a = 1;");
2724 let var = stmt.to_var().unwrap();
2725
2726 assert_eq!(false, var.reassignable);
2727 assert!(var.data_type.is_none());
2728 assert!(var.expr.as_ref().unwrap().is_lit_int());
2729 }
2730
2731 #[test]
2732 fn parse_var_without_type() {
2733 let stmt = parse_stmt("var a = 1;");
2734 let var = stmt.to_var().unwrap();
2735
2736 assert_eq!(true, var.reassignable);
2737 assert!(var.data_type.is_none());
2738 assert!(var.expr.as_ref().unwrap().is_lit_int());
2739 }
2740
2741 #[test]
2742 fn parse_let_with_type() {
2743 let stmt = parse_stmt("let x : int = 1;");
2744 let var = stmt.to_var().unwrap();
2745
2746 assert_eq!(false, var.reassignable);
2747 assert!(var.data_type.is_some());
2748 assert!(var.expr.as_ref().unwrap().is_lit_int());
2749 }
2750
2751 #[test]
2752 fn parse_var_with_type() {
2753 let stmt = parse_stmt("var x : int = 1;");
2754 let var = stmt.to_var().unwrap();
2755
2756 assert_eq!(true, var.reassignable);
2757 assert!(var.data_type.is_some());
2758 assert!(var.expr.as_ref().unwrap().is_lit_int());
2759 }
2760
2761 #[test]
2762 fn parse_let_with_type_but_without_assignment() {
2763 let stmt = parse_stmt("let x : int;");
2764 let var = stmt.to_var().unwrap();
2765
2766 assert_eq!(false, var.reassignable);
2767 assert!(var.data_type.is_some());
2768 assert!(var.expr.is_none());
2769 }
2770
2771 #[test]
2772 fn parse_var_with_type_but_without_assignment() {
2773 let stmt = parse_stmt("var x : int;");
2774 let var = stmt.to_var().unwrap();
2775
2776 assert_eq!(true, var.reassignable);
2777 assert!(var.data_type.is_some());
2778 assert!(var.expr.is_none());
2779 }
2780
2781 #[test]
2782 fn parse_let_without_type_and_assignment() {
2783 let stmt = parse_stmt("let x;");
2784 let var = stmt.to_var().unwrap();
2785
2786 assert_eq!(false, var.reassignable);
2787 assert!(var.data_type.is_none());
2788 assert!(var.expr.is_none());
2789 }
2790
2791 #[test]
2792 fn parse_var_without_type_and_assignment() {
2793 let stmt = parse_stmt("var x;");
2794 let var = stmt.to_var().unwrap();
2795
2796 assert_eq!(true, var.reassignable);
2797 assert!(var.data_type.is_none());
2798 assert!(var.expr.is_none());
2799 }
2800
2801 #[test]
2802 fn parse_multiple_functions() {
2803 let (prog, interner) = parse("fun f() { } fun g() { }");
2804
2805 let f = prog.fct0();
2806 assert_eq!("f", *interner.str(f.name));
2807 assert_eq!(false, f.method);
2808 assert_eq!(Position::new(1, 1), f.pos);
2809
2810 let g = prog.fct(1);
2811 assert_eq!("g", *interner.str(g.name));
2812 assert_eq!(false, g.method);
2813 assert_eq!(Position::new(1, 13), g.pos);
2814 }
2815
2816 #[test]
2817 fn parse_expr_stmt() {
2818 let stmt = parse_stmt("1;");
2819 let expr = stmt.to_expr().unwrap();
2820
2821 assert!(expr.expr.is_lit_int());
2822 }
2823
2824 #[test]
2825 fn parse_expr_stmt_without_semicolon() {
2826 err_stmt(
2827 "1",
2828 ParseError::ExpectedToken(";".into(), "<<EOF>>".into()),
2829 1,
2830 2,
2831 );
2832 }
2833
2834 #[test]
2835 fn parse_if() {
2836 let (expr, _) = parse_expr("if true { 2; } else { 3; }");
2837 let ifexpr = expr.to_if().unwrap();
2838
2839 assert!(ifexpr.cond.is_lit_bool());
2840 assert!(ifexpr.else_block.is_some());
2841 }
2842
2843 #[test]
2844 fn parse_if_without_else() {
2845 let (expr, _) = parse_expr("if true { 2; }");
2846 let ifexpr = expr.to_if().unwrap();
2847
2848 assert!(ifexpr.cond.is_lit_bool());
2849 assert!(ifexpr.else_block.is_none());
2850 }
2851
2852 #[test]
2853 fn parse_while() {
2854 let stmt = parse_stmt("while true { 2; }");
2855 let whilestmt = stmt.to_while().unwrap();
2856
2857 assert!(whilestmt.cond.is_lit_bool());
2858 assert!(whilestmt.block.is_expr());
2859 }
2860
2861 #[test]
2862 fn parse_loop() {
2863 let stmt = parse_stmt("loop { 1; }");
2864 let block = &stmt.to_loop().unwrap().block;
2865
2866 assert!(block.is_expr());
2867 }
2868
2869 #[test]
2870 fn parse_empty_block() {
2871 let (expr, _) = parse_expr("{}");
2872 let block = expr.to_block().unwrap();
2873
2874 assert_eq!(0, block.stmts.len());
2875 }
2876
2877 #[test]
2878 fn parse_block_with_one_stmt() {
2879 let (expr, _) = parse_expr("{ 1; 2 }");
2880 let block = expr.to_block().unwrap();
2881
2882 assert_eq!(1, block.stmts.len());
2883
2884 let expr = &block.stmts[0].to_expr().unwrap().expr;
2885 assert_eq!(1, expr.to_lit_int().unwrap().value);
2886
2887 assert_eq!(2, block.expr.as_ref().unwrap().to_lit_int().unwrap().value);
2888 }
2889
2890 #[test]
2891 fn parse_block_with_multiple_stmts() {
2892 let (expr, _) = parse_expr("{ 1; 2; }");
2893 let block = expr.to_block().unwrap();
2894
2895 assert_eq!(2, block.stmts.len());
2896
2897 let expr = &block.stmts[0].to_expr().unwrap().expr;
2898 assert_eq!(1, expr.to_lit_int().unwrap().value);
2899
2900 let expr = &block.stmts[1].to_expr().unwrap().expr;
2901 assert_eq!(2, expr.to_lit_int().unwrap().value);
2902
2903 assert!(block.expr.is_none());
2904 }
2905
2906 #[test]
2907 fn parse_break() {
2908 let stmt = parse_stmt("break;");
2909
2910 assert!(stmt.is_break());
2911 }
2912
2913 #[test]
2914 fn parse_continue() {
2915 let stmt = parse_stmt("continue;");
2916
2917 assert!(stmt.is_continue());
2918 }
2919
2920 #[test]
2921 fn parse_return_value() {
2922 let stmt = parse_stmt("return 1;");
2923 let ret = stmt.to_return().unwrap();
2924
2925 assert_eq!(1, ret.expr.as_ref().unwrap().to_lit_int().unwrap().value);
2926 }
2927
2928 #[test]
2929 fn parse_return() {
2930 let stmt = parse_stmt("return;");
2931 let ret = stmt.to_return().unwrap();
2932
2933 assert!(ret.expr.is_none());
2934 }
2935
2936 #[test]
2937 fn parse_else() {
2938 err_stmt("else", ParseError::MisplacedElse, 1, 1);
2939 }
2940
2941 #[test]
2942 fn parse_type_basic() {
2943 let (ty, interner) = parse_type("bla");
2944 let basic = ty.to_basic().unwrap();
2945
2946 assert_eq!(0, basic.params.len());
2947 assert_eq!("bla", *interner.str(basic.name));
2948 }
2949
2950 #[test]
2951 fn parse_type_basic_with_params() {
2952 let (ty, interner) = parse_type("Foo[A, B]");
2953 let basic = ty.to_basic().unwrap();
2954
2955 assert_eq!(2, basic.params.len());
2956 assert_eq!("Foo", *interner.str(basic.name));
2957 assert_eq!("A", *interner.str(basic.params[0].to_basic().unwrap().name));
2958 assert_eq!("B", *interner.str(basic.params[1].to_basic().unwrap().name));
2959 }
2960
2961 #[test]
2962 fn parse_type_fct_no_params() {
2963 let (ty, _) = parse_type("() -> ()");
2964 let fct = ty.to_fct().unwrap();
2965
2966 assert_eq!(0, fct.params.len());
2967 assert!(fct.ret.is_unit());
2968 }
2969
2970 #[test]
2971 fn parse_type_fct_one_param() {
2972 let (ty, interner) = parse_type("(A) -> B");
2973 let fct = ty.to_fct().unwrap();
2974
2975 assert_eq!(1, fct.params.len());
2976 assert_eq!("A", *interner.str(fct.params[0].to_basic().unwrap().name));
2977 assert_eq!("B", *interner.str(fct.ret.to_basic().unwrap().name));
2978 }
2979
2980 #[test]
2981 fn parse_type_fct_two_params() {
2982 let (ty, interner) = parse_type("(A, B) -> C");
2983 let fct = ty.to_fct().unwrap();
2984
2985 assert_eq!(2, fct.params.len());
2986 assert_eq!("A", *interner.str(fct.params[0].to_basic().unwrap().name));
2987 assert_eq!("B", *interner.str(fct.params[1].to_basic().unwrap().name));
2988 assert_eq!("C", *interner.str(fct.ret.to_basic().unwrap().name));
2989 }
2990
2991 #[test]
2992 fn parse_type_unit() {
2993 let (ty, _) = parse_type("()");
2994 let ty = ty.to_tuple().unwrap();
2995
2996 assert!(ty.subtypes.is_empty());
2997 }
2998
2999 #[test]
3000 fn parse_type_tuple_with_one_type() {
3001 let (ty, interner) = parse_type("(c)");
3002
3003 let subtypes = &ty.to_tuple().unwrap().subtypes;
3004 assert_eq!(1, subtypes.len());
3005
3006 let ty = subtypes[0].to_basic().unwrap();
3007 assert_eq!("c", *interner.str(ty.name));
3008 }
3009
3010 #[test]
3011 fn parse_type_tuple_with_two_types() {
3012 let (ty, interner) = parse_type("(a, b)");
3013
3014 let subtypes = &ty.to_tuple().unwrap().subtypes;
3015 assert_eq!(2, subtypes.len());
3016
3017 let ty1 = subtypes[0].to_basic().unwrap();
3018 assert_eq!("a", *interner.str(ty1.name));
3019
3020 let ty2 = subtypes[1].to_basic().unwrap();
3021 assert_eq!("b", *interner.str(ty2.name));
3022 }
3023
3024 #[test]
3025 fn parse_method() {
3026 let (prog, interner) = parse(
3027 "class Foo {
3028 fun zero() -> int { return 0; }
3029 fun id(a: String) -> String { return a; }
3030 }",
3031 );
3032
3033 let cls = prog.cls0();
3034 assert_eq!(0, cls.fields.len());
3035 assert_eq!(2, cls.methods.len());
3036
3037 let mtd1 = &cls.methods[0];
3038 assert_eq!("zero", *interner.str(mtd1.name));
3039 assert_eq!(0, mtd1.params.len());
3040 assert_eq!(true, mtd1.method);
3041 let rt1 = mtd1.return_type.as_ref().unwrap().to_basic().unwrap().name;
3042 assert_eq!("int", *interner.str(rt1));
3043
3044 let mtd2 = &cls.methods[1];
3045 assert_eq!("id", *interner.str(mtd2.name));
3046 assert_eq!(1, mtd2.params.len());
3047 assert_eq!(true, mtd2.method);
3048 let rt2 = mtd2.return_type.as_ref().unwrap().to_basic().unwrap().name;
3049 assert_eq!("String", *interner.str(rt2));
3050 }
3051
3052 #[test]
3053 fn parse_abstract_method() {
3054 let (prog, _) = parse(
3055 "class Foo {
3056 @abstract fun zero();
3057 fun foo();
3058 }",
3059 );
3060
3061 let cls = prog.cls0();
3062 assert_eq!(0, cls.fields.len());
3063 assert_eq!(2, cls.methods.len());
3064
3065 let mtd1 = &cls.methods[0];
3066 assert_eq!(true, mtd1.is_abstract);
3067
3068 let mtd2 = &cls.methods[1];
3069 assert_eq!(false, mtd2.is_abstract);
3070 }
3071
3072 #[test]
3073 fn parse_class() {
3074 let (prog, interner) = parse("class Foo");
3075 let class = prog.cls0();
3076
3077 assert_eq!(0, class.fields.len());
3078 assert_eq!(false, class.has_open);
3079 assert_eq!(false, class.is_abstract);
3080 assert_eq!(Position::new(1, 1), class.pos);
3081 assert_eq!("Foo", *interner.str(class.name));
3082 }
3083
3084 #[test]
3085 fn parse_class_abstract() {
3086 let (prog, interner) = parse("@abstract class Foo");
3087 let class = prog.cls0();
3088
3089 assert_eq!(true, class.is_abstract);
3090 assert_eq!("Foo", *interner.str(class.name));
3091 }
3092
3093 #[test]
3094 fn parse_class_with_parens_but_no_params() {
3095 let (prog, interner) = parse("@open class Foo()");
3096 let class = prog.cls0();
3097
3098 assert_eq!(0, class.fields.len());
3099 assert_eq!(true, class.has_open);
3100 assert_eq!(Position::new(1, 7), class.pos);
3101 assert_eq!("Foo", *interner.str(class.name));
3102 }
3103
3104 #[test]
3105 fn parse_class_with_param() {
3106 let (prog, _) = parse("class Foo(a: int)");
3107 let class = prog.cls0();
3108 let ctor = class.constructor.clone().unwrap();
3109
3110 assert_eq!(0, class.fields.len());
3111 assert_eq!(true, class.has_constructor);
3112 assert_eq!(1, ctor.params.len());
3113 assert_eq!(false, ctor.params[0].reassignable);
3114 }
3115
3116 #[test]
3117 fn parse_class_with_param_var() {
3118 let (prog, _) = parse("class Foo(var a: int)");
3119 let class = prog.cls0();
3120
3121 assert_eq!(1, class.fields.len());
3122 assert_eq!(true, class.fields[0].reassignable);
3123 assert_eq!(true, class.has_constructor);
3124 assert_eq!(1, class.constructor.clone().unwrap().params.len());
3125 }
3126
3127 #[test]
3128 fn parse_class_with_param_let() {
3129 let (prog, _) = parse("class Foo(let a: int)");
3130 let class = prog.cls0();
3131 let ctor = class.constructor.clone().unwrap();
3132
3133 assert_eq!(1, class.fields.len());
3134 assert_eq!(false, class.fields[0].reassignable);
3135 assert_eq!(true, class.has_constructor);
3136 assert_eq!(1, ctor.params.len());
3137 assert_eq!(false, ctor.params[0].reassignable);
3138 }
3139
3140 #[test]
3141 fn parse_class_with_params() {
3142 let (prog, _) = parse("class Foo(a: int, b: int)");
3143 let class = prog.cls0();
3144
3145 assert_eq!(0, class.fields.len());
3146 assert_eq!(2, class.constructor.clone().unwrap().params.len());
3147 }
3148
3149 #[test]
3150 fn parse_class_with_parent_class() {
3151 let (prog, interner) = parse("class Foo : Bar");
3152 let class = prog.cls0();
3153
3154 assert_eq!(
3155 "Bar",
3156 interner
3157 .str(class.parent_class.as_ref().unwrap().name)
3158 .to_string()
3159 );
3160 }
3161
3162 #[test]
3163 fn parse_class_with_open() {
3164 let (prog, _) = parse("@open class Foo");
3165 let class = prog.cls0();
3166
3167 assert_eq!(true, class.has_open);
3168 }
3169
3170 #[test]
3171 fn parse_module() {
3172 let (prog, interner) = parse("module Foo");
3173 let module = prog.mod0();
3174
3175 assert_eq!(0, module.fields.len());
3176 assert_eq!(Position::new(1, 1), module.pos);
3177 assert_eq!("Foo", *interner.str(module.name));
3178 }
3179
3180 #[test]
3181 fn parse_module_with_parent() {
3182 let (prog, interner) = parse("module Foo : Bar");
3183 let module = prog.mod0();
3184
3185 assert_eq!(
3186 "Bar",
3187 interner
3188 .str(module.parent_class.as_ref().unwrap().name)
3189 .to_string()
3190 );
3191 }
3192
3193 #[test]
3194 fn parse_module_with_body() {
3195 let (prog, _) =
3196 parse("module Foo { let x: Int = 23; var y: String = \"abc\"; fun z() {} }");
3197 let module = prog.mod0();
3198
3199 assert_eq!(2, module.fields.len());
3200 assert_eq!(1, module.methods.len());
3201 }
3202
3203 #[test]
3204 fn parse_method_invocation() {
3205 let (expr, _) = parse_expr("a.foo()");
3206 let call = expr.to_call().unwrap();
3207 assert!(call.callee.is_dot());
3208 assert_eq!(0, call.args.len());
3209
3210 let (expr, _) = parse_expr("a.foo(1)");
3211 let call = expr.to_call().unwrap();
3212 assert!(call.callee.is_dot());
3213 assert_eq!(1, call.args.len());
3214
3215 let (expr, _) = parse_expr("a.foo(1,2)");
3216 let call = expr.to_call().unwrap();
3217 assert!(call.callee.is_dot());
3218 assert_eq!(2, call.args.len());
3219 }
3220
3221 #[test]
3222 fn parse_array_index() {
3223 let (expr, interner) = parse_expr("a(b)");
3224 let call = expr.to_call().unwrap();
3225 assert_eq!("a", *interner.str(call.callee.to_ident().unwrap().name));
3226 assert_eq!(1, call.args.len());
3227 assert_eq!("b", *interner.str(call.args[0].to_ident().unwrap().name));
3228 }
3229
3230 #[test]
3231 fn parse_function_without_throws() {
3232 let (prog, _) = parse("fun f(a: int) {}");
3233 let fct = prog.fct0();
3234 assert!(!fct.throws);
3235 }
3236
3237 #[test]
3238 fn parse_function_throws() {
3239 let (prog, _) = parse("fun f(a: int) throws {}");
3240 let fct = prog.fct0();
3241 assert!(fct.throws);
3242 }
3243
3244 #[test]
3245 fn parse_function_throws_with_return_type() {
3246 let (prog, _) = parse("fun f(a: int) throws -> int { return 0; }");
3247 let fct = prog.fct0();
3248 assert!(fct.throws);
3249 }
3250
3251 #[test]
3252 fn parse_throw() {
3253 let stmt = parse_stmt("throw 1;");
3254 let throw = stmt.to_throw().unwrap();
3255
3256 assert!(throw.expr.is_lit_int());
3257 }
3258
3259 #[test]
3260 fn parse_defer() {
3261 let stmt = parse_stmt("defer foo();");
3262 let defer = stmt.to_defer().unwrap();
3263
3264 assert!(defer.expr.is_call());
3265 }
3266
3267 #[test]
3268 fn parse_do() {
3269 let stmt = parse_stmt(
3270 "do { 1; } catch e: String { 2; }
3271 catch e: IntArray { 3; } finally { 4; }",
3272 );
3273 let r#try = stmt.to_do().unwrap();
3274
3275 assert_eq!(2, r#try.catch_blocks.len());
3276 assert!(r#try.finally_block.is_some());
3277 }
3278
3279 #[test]
3280 fn parse_do_without_catch() {
3281 let stmt = parse_stmt("do { 1; }");
3282 let r#try = stmt.to_do().unwrap();
3283
3284 assert_eq!(0, r#try.catch_blocks.len());
3285 assert!(r#try.finally_block.is_none());
3286 }
3287
3288 #[test]
3289 fn parse_field() {
3290 let (prog, interner) = parse("class A { var f1: int; let f2: int = 0; }");
3291 let cls = prog.cls0();
3292
3293 let f1 = &cls.fields[0];
3294 assert_eq!("f1", &interner.str(f1.name).to_string());
3295 assert_eq!(true, f1.reassignable);
3296
3297 let f2 = &cls.fields[1];
3298 assert_eq!("f2", &interner.str(f2.name).to_string());
3299 assert_eq!(false, f2.reassignable);
3300 }
3301
3302 #[test]
3303 fn parse_open_method() {
3304 let (prog, _) = parse("class A { @open fun f() {} fun g() {} }");
3305 let cls = prog.cls0();
3306
3307 let m1 = &cls.methods[0];
3308 assert_eq!(true, m1.has_open);
3309
3310 let m2 = &cls.methods[1];
3311 assert_eq!(false, m2.has_open);
3312 }
3313
3314 #[test]
3315 fn parse_override_method() {
3316 let (prog, _) = parse(
3317 "class A { fun f() {}
3318 @override fun g() {}
3319 @open fun h() {} }",
3320 );
3321 let cls = prog.cls0();
3322
3323 let m1 = &cls.methods[0];
3324 assert_eq!(false, m1.has_override);
3325 assert_eq!(false, m1.has_open);
3326
3327 let m2 = &cls.methods[1];
3328 assert_eq!(true, m2.has_override);
3329 assert_eq!(false, m2.has_open);
3330
3331 let m3 = &cls.methods[2];
3332 assert_eq!(false, m3.has_override);
3333 assert_eq!(true, m3.has_open);
3334 }
3335
3336 #[test]
3337 fn parse_parent_class_params() {
3338 let (prog, _) = parse("class A: B(1, 2)");
3339 let cls = prog.cls0();
3340
3341 let parent_class = cls.parent_class.as_ref().unwrap();
3342 assert_eq!(2, parent_class.params.len());
3343 }
3344
3345 #[test]
3346 fn parse_final_method() {
3347 let (prog, _) = parse("@open class A { @final @override fun g() {} }");
3348 let cls = prog.cls0();
3349
3350 let m1 = &cls.methods[0];
3351 assert_eq!(true, m1.has_override);
3352 assert_eq!(false, m1.has_open);
3353 assert_eq!(true, m1.has_final);
3354 }
3355
3356 #[test]
3357 fn parse_is_expr() {
3358 let (expr, _) = parse_expr("a is String");
3359 let expr = expr.to_conv().unwrap();
3360 assert_eq!(true, expr.object.is_ident());
3361 assert_eq!(true, expr.is);
3362 }
3363
3364 #[test]
3365 fn parse_as_expr() {
3366 let (expr, _) = parse_expr("a as String");
3367 let expr = expr.to_conv().unwrap();
3368 assert_eq!(true, expr.object.is_ident());
3369 assert_eq!(false, expr.is);
3370 }
3371
3372 #[test]
3373 fn parse_internal() {
3374 let (prog, _) = parse("@internal fun foo();");
3375 let fct = prog.fct0();
3376 assert!(fct.internal);
3377 }
3378
3379 #[test]
3380 fn parse_function_without_body() {
3381 let (prog, _) = parse("fun foo();");
3382 let fct = prog.fct0();
3383 assert!(fct.block.is_none());
3384 }
3385
3386 #[test]
3387 fn parse_internal_class() {
3388 let (prog, _) = parse("@internal class Foo {}");
3389 let cls = prog.cls0();
3390 assert!(cls.internal);
3391 }
3392
3393 #[test]
3394 fn parse_try_function() {
3395 let (expr, _) = parse_expr("try foo()");
3396 let r#try = expr.to_try().unwrap();
3397 let call = r#try.expr.to_call().unwrap();
3398
3399 assert!(r#try.mode.is_normal());
3400 assert!(call.callee.is_ident());
3401 assert_eq!(0, call.args.len());
3402 }
3403
3404 #[test]
3405 fn parse_try_method() {
3406 let (expr, _) = parse_expr("try obj.foo()");
3407 let r#try = expr.to_try().unwrap();
3408 let call = r#try.expr.to_call().unwrap();
3409
3410 assert!(r#try.mode.is_normal());
3411 assert!(call.callee.is_dot());
3412 assert_eq!(0, call.args.len());
3413 }
3414
3415 #[test]
3416 fn parse_try_expr() {
3417 let (expr, _) = parse_expr("try 1");
3419 let r#try = expr.to_try().unwrap();
3420
3421 assert!(r#try.mode.is_normal());
3422 assert!(r#try.expr.is_lit_int());
3423 }
3424
3425 #[test]
3426 fn parse_try_with_else() {
3427 let (expr, _) = parse_expr("try foo() else 2");
3428 let r#try = expr.to_try().unwrap();
3429
3430 assert!(r#try.mode.is_else());
3431 }
3432
3433 #[test]
3434 fn parse_try_force() {
3435 let (expr, _) = parse_expr("try! foo()");
3436 let r#try = expr.to_try().unwrap();
3437
3438 assert!(r#try.mode.is_force());
3439 }
3440
3441 #[test]
3442 fn parse_try_opt() {
3443 let (expr, _) = parse_expr("try? foo()");
3444 let r#try = expr.to_try().unwrap();
3445
3446 assert!(r#try.mode.is_opt());
3447 }
3448
3449 #[test]
3450 fn parse_struct_empty() {
3451 let (prog, interner) = parse("struct Foo {}");
3452 let struc = prog.struct0();
3453 assert_eq!(0, struc.fields.len());
3454 assert_eq!("Foo", *interner.str(struc.name));
3455 }
3456
3457 #[test]
3458 fn parse_struct_one_field() {
3459 let (prog, interner) = parse(
3460 "struct Bar {
3461 f1: Foo1,
3462 }",
3463 );
3464 let struc = prog.struct0();
3465 assert_eq!(1, struc.fields.len());
3466 assert_eq!("Bar", *interner.str(struc.name));
3467
3468 let f1 = &struc.fields[0];
3469 assert_eq!("f1", *interner.str(f1.name));
3470 }
3471
3472 #[test]
3473 fn parse_struct_multiple_fields() {
3474 let (prog, interner) = parse(
3475 "struct FooBar {
3476 fa: Foo1,
3477 fb: Foo2,
3478 }",
3479 );
3480 let struc = prog.struct0();
3481 assert_eq!(2, struc.fields.len());
3482 assert_eq!("FooBar", *interner.str(struc.name));
3483
3484 let f1 = &struc.fields[0];
3485 assert_eq!("fa", *interner.str(f1.name));
3486
3487 let f2 = &struc.fields[1];
3488 assert_eq!("fb", *interner.str(f2.name));
3489 }
3490
3491 #[test]
3492 fn parse_struct_lit_while() {
3493 let stmt = parse_stmt("while i < n { }");
3494 let while_stmt = stmt.to_while().unwrap();
3495 let bin = while_stmt.cond.to_bin().unwrap();
3496
3497 assert!(bin.lhs.is_ident());
3498 assert!(bin.rhs.is_ident());
3499 }
3500
3501 #[test]
3502 fn parse_struct_lit_if() {
3503 let (expr, _) = parse_expr("if i < n { }");
3504 let ifexpr = expr.to_if().unwrap();
3505 let bin = ifexpr.cond.to_bin().unwrap();
3506
3507 assert!(bin.lhs.is_ident());
3508 assert!(bin.rhs.is_ident());
3509 }
3510
3511 #[test]
3512 fn parse_lit_float() {
3513 let (expr, _) = parse_expr("1.2");
3514
3515 let lit = expr.to_lit_float().unwrap();
3516
3517 assert_eq!(1.2, lit.value);
3518 }
3519
3520 #[test]
3521 fn parse_template() {
3522 let (expr, _) = parse_expr("\"a${1}b${2}c\"");
3523 let tmpl = expr.to_template().unwrap();
3524 assert_eq!(tmpl.parts.len(), 5);
3525
3526 assert_eq!("a".to_string(), tmpl.parts[0].to_lit_str().unwrap().value);
3527 assert_eq!(1, tmpl.parts[1].to_lit_int().unwrap().value);
3528 assert_eq!("b".to_string(), tmpl.parts[2].to_lit_str().unwrap().value);
3529 assert_eq!(2, tmpl.parts[3].to_lit_int().unwrap().value);
3530 assert_eq!("c".to_string(), tmpl.parts[4].to_lit_str().unwrap().value);
3531
3532 let (expr, _) = parse_expr("\"a\\${1}b\"");
3533 assert!(expr.is_lit_str());
3534 }
3535
3536 #[test]
3537 fn parse_class_type_params() {
3538 let (prog, interner) = parse("class Foo[T]");
3539 let cls = prog.cls0();
3540
3541 let type_params = cls.type_params.as_ref().unwrap();
3542 assert_eq!(1, type_params.len());
3543 assert_eq!("T", *interner.str(type_params[0].name));
3544
3545 let (prog, interner) = parse("class Foo[X]");
3546 let cls = prog.cls0();
3547
3548 let type_params = cls.type_params.as_ref().unwrap();
3549 assert_eq!(1, type_params.len());
3550 assert_eq!("X", *interner.str(type_params[0].name));
3551 }
3552
3553 #[test]
3554 fn parse_multiple_class_type_params() {
3555 let (prog, interner) = parse("class Foo[A, B]");
3556 let cls = prog.cls0();
3557
3558 let type_params = cls.type_params.as_ref().unwrap();
3559 assert_eq!(2, type_params.len());
3560 assert_eq!("A", *interner.str(type_params[0].name));
3561 assert_eq!("B", *interner.str(type_params[1].name));
3562 }
3563
3564 #[test]
3565 fn parse_empty_trait() {
3566 let (prog, interner) = parse("trait Foo { }");
3567 let xtrait = prog.trait0();
3568
3569 assert_eq!("Foo", *interner.str(xtrait.name));
3570 assert_eq!(0, xtrait.methods.len());
3571 }
3572
3573 #[test]
3574 fn parse_trait_with_function() {
3575 let (prog, interner) = parse("trait Foo { fun empty(); }");
3576 let xtrait = prog.trait0();
3577
3578 assert_eq!("Foo", *interner.str(xtrait.name));
3579 assert_eq!(1, xtrait.methods.len());
3580 assert_eq!(false, xtrait.methods[0].is_static);
3581 }
3582
3583 #[test]
3584 fn parse_trait_with_static_function() {
3585 let (prog, interner) = parse("trait Foo { @static fun empty(); }");
3586 let xtrait = prog.trait0();
3587
3588 assert_eq!("Foo", *interner.str(xtrait.name));
3589 assert_eq!(1, xtrait.methods.len());
3590 assert_eq!(true, xtrait.methods[0].is_static);
3591 }
3592
3593 #[test]
3594 fn parse_empty_impl() {
3595 let (prog, interner) = parse("impl Foo for A {}");
3596 let ximpl = prog.impl0();
3597
3598 assert_eq!(
3599 "Foo",
3600 ximpl.trait_type.as_ref().unwrap().to_string(&interner)
3601 );
3602 assert_eq!("A", ximpl.class_type.to_string(&interner));
3603 assert_eq!(0, ximpl.methods.len());
3604 }
3605
3606 #[test]
3607 fn parse_impl_with_function() {
3608 let (prog, interner) = parse("impl Bar for B { fun foo(); }");
3609 let ximpl = prog.impl0();
3610
3611 assert_eq!(
3612 "Bar",
3613 ximpl.trait_type.as_ref().unwrap().to_string(&interner)
3614 );
3615 assert_eq!("B", ximpl.class_type.to_string(&interner));
3616 assert_eq!(1, ximpl.methods.len());
3617 assert_eq!(false, ximpl.methods[0].is_static);
3618 }
3619
3620 #[test]
3621 fn parse_impl_with_static_function() {
3622 let (prog, interner) = parse("impl Bar for B { @static fun foo(); }");
3623 let ximpl = prog.impl0();
3624
3625 assert_eq!(
3626 "Bar",
3627 ximpl.trait_type.as_ref().unwrap().to_string(&interner)
3628 );
3629 assert_eq!("B", ximpl.class_type.to_string(&interner));
3630 assert_eq!(1, ximpl.methods.len());
3631 assert_eq!(true, ximpl.methods[0].is_static);
3632 }
3633
3634 #[test]
3635 fn parse_global_var() {
3636 let (prog, interner) = parse("var a: int = 0;");
3637 let global = prog.global0();
3638
3639 assert_eq!("a", *interner.str(global.name));
3640 assert_eq!(true, global.reassignable);
3641 }
3642
3643 #[test]
3644 fn parse_global_let() {
3645 let (prog, interner) = parse("let b: int = 0;");
3646 let global = prog.global0();
3647
3648 assert_eq!("b", *interner.str(global.name));
3649 assert_eq!(false, global.reassignable);
3650 }
3651
3652 #[test]
3653 fn parse_lit_char() {
3654 let (expr, _) = parse_expr("'a'");
3655 let lit = expr.to_lit_char().unwrap();
3656
3657 assert_eq!('a', lit.value);
3658 }
3659
3660 #[test]
3661 fn parse_fct_call_with_type_param() {
3662 let (expr, _) = parse_expr("Array[Int]()");
3663 let call = expr.to_call().unwrap();
3664 let type_params = call.callee.to_type_param().unwrap();
3665
3666 assert_eq!(1, type_params.args.len());
3667
3668 let (expr, _) = parse_expr("Foo[Int, Long]()");
3669 let call = expr.to_call().unwrap();
3670 let type_params = call.callee.to_type_param().unwrap();
3671
3672 assert_eq!(2, type_params.args.len());
3673
3674 let (expr, _) = parse_expr("Bar[]()");
3675 let call = expr.to_call().unwrap();
3676 let type_params = call.callee.to_type_param().unwrap();
3677
3678 assert_eq!(0, type_params.args.len());
3679
3680 let (expr, _) = parse_expr("Vec()");
3681 let call = expr.to_call().unwrap();
3682
3683 assert!(call.callee.is_ident());
3684 }
3685
3686 #[test]
3687 fn parse_static_method() {
3688 let (prog, _) = parse(
3689 "class A {
3690 @static fun test() {}
3691 }",
3692 );
3693 let cls = prog.cls0();
3694 assert_eq!(1, cls.methods.len());
3695
3696 let mtd = &cls.methods[0];
3697 assert!(mtd.is_static);
3698 }
3699
3700 #[test]
3701 fn parse_call_with_path() {
3702 let (expr, _) = parse_expr("Foo::get()");
3703 let call = expr.to_call().unwrap();
3704
3705 assert!(call.callee.is_path());
3706 assert_eq!(0, call.args.len());
3707 }
3708
3709 #[test]
3710 fn parse_fct_with_type_params() {
3711 let (prog, _) = parse("fun f[T]() {}");
3712 let fct = prog.fct0();
3713
3714 assert_eq!(1, fct.type_params.as_ref().unwrap().len());
3715 }
3716
3717 #[test]
3718 fn parse_const() {
3719 let (prog, interner) = parse("const x: int = 0;");
3720 let xconst = prog.const0();
3721
3722 assert_eq!("x", *interner.str(xconst.name));
3723 }
3724
3725 #[test]
3726 fn parse_generic_with_bound() {
3727 let (prog, _) = parse("class A[T: Foo]");
3728 let cls = prog.cls0();
3729
3730 let type_param = &cls.type_params.as_ref().unwrap()[0];
3731 assert_eq!(1, type_param.bounds.len());
3732 }
3733
3734 #[test]
3735 fn parse_generic_with_multiple_bounds() {
3736 let (prog, _) = parse("class A[T: Foo + Bar]");
3737 let cls = prog.cls0();
3738
3739 let type_param = &cls.type_params.as_ref().unwrap()[0];
3740 assert_eq!(2, type_param.bounds.len());
3741 }
3742
3743 #[test]
3744 fn parse_generic_super_class() {
3745 let (prog, _) = parse("class A: B[SomeType, SomeOtherType]");
3746 let cls = prog.cls0();
3747
3748 let parent = cls.parent_class.as_ref().unwrap();
3749 assert_eq!(2, parent.type_params.len());
3750 }
3751
3752 #[test]
3753 fn parse_generic_super_class_with_nested_type_definition() {
3754 let (prog, _) = parse("class A: B[SomeType[SomeOtherType[Int]]]");
3755 let cls = prog.cls0();
3756
3757 let parent = cls.parent_class.as_ref().unwrap();
3758 assert_eq!(1, parent.type_params.len());
3759 }
3760
3761 #[test]
3762 fn parse_lambda_no_params_no_return_value() {
3763 let (expr, _) = parse_expr("|| {}");
3764 let lambda = expr.to_lambda().unwrap();
3765
3766 assert!(lambda.ret.is_none());
3767 }
3768
3769 #[test]
3770 fn parse_lambda_no_params_unit_as_return_value() {
3771 let (expr, _) = parse_expr("|| -> () {}");
3772 let lambda = expr.to_lambda().unwrap();
3773 let ret = lambda.ret.as_ref().unwrap();
3774
3775 assert!(ret.is_unit());
3776 }
3777
3778 #[test]
3779 fn parse_lambda_no_params_with_return_value() {
3780 let (expr, interner) = parse_expr("|| -> A {}");
3781 let lambda = expr.to_lambda().unwrap();
3782 let ret = lambda.ret.as_ref().unwrap();
3783 let basic = ret.to_basic().unwrap();
3784
3785 assert_eq!("A", *interner.str(basic.name));
3786 }
3787
3788 #[test]
3789 fn parse_lambda_with_one_param() {
3790 let (expr, interner) = parse_expr("|a: A| -> B {}");
3791 let lambda = expr.to_lambda().unwrap();
3792
3793 assert_eq!(1, lambda.params.len());
3794
3795 let param = &lambda.params[0];
3796 assert_eq!("a", *interner.str(param.name));
3797 let basic = param.data_type.to_basic().unwrap();
3798 assert_eq!("A", *interner.str(basic.name));
3799
3800 let ret = lambda.ret.as_ref().unwrap();
3801 let basic = ret.to_basic().unwrap();
3802
3803 assert_eq!("B", *interner.str(basic.name));
3804 }
3805
3806 #[test]
3807 fn parse_lambda_with_two_params() {
3808 let (expr, interner) = parse_expr("|a: A, b: B| -> C {}");
3809 let lambda = expr.to_lambda().unwrap();
3810
3811 assert_eq!(2, lambda.params.len());
3812
3813 let param = &lambda.params[0];
3814 assert_eq!("a", *interner.str(param.name));
3815 let basic = param.data_type.to_basic().unwrap();
3816 assert_eq!("A", *interner.str(basic.name));
3817
3818 let param = &lambda.params[1];
3819 assert_eq!("b", *interner.str(param.name));
3820 let basic = param.data_type.to_basic().unwrap();
3821 assert_eq!("B", *interner.str(basic.name));
3822
3823 let ret = lambda.ret.as_ref().unwrap();
3824 let basic = ret.to_basic().unwrap();
3825
3826 assert_eq!("C", *interner.str(basic.name));
3827 }
3828
3829 #[test]
3830 fn parse_for() {
3831 let stmt = parse_stmt("for i in a+b {}");
3832 assert!(stmt.is_for());
3833 }
3834
3835 #[test]
3836 fn parse_new_call_ident() {
3837 let (expr, _interner) = parse_expr("i");
3838 assert!(expr.is_ident());
3839 }
3840
3841 #[test]
3842 fn parse_new_call_path() {
3843 let (expr, _interner) = parse_expr("Foo::bar");
3844 let path = expr.to_path().unwrap();
3845 assert!(path.lhs.is_ident());
3846 assert!(path.rhs.is_ident());
3847 }
3848
3849 #[test]
3850 fn parse_new_call_call() {
3851 let (expr, _interner) = parse_expr("foo(1,2)");
3852 let call = expr.to_call().unwrap();
3853 assert!(call.callee.is_ident());
3854 assert_eq!(call.args.len(), 2);
3855 }
3856
3857 #[test]
3858 fn parse_block() {
3859 let (expr, _) = parse_expr("{1}");
3860 assert!(expr.to_block().unwrap().expr.as_ref().unwrap().is_lit_int());
3861
3862 let (expr, _) = parse_expr("({}) + 1");
3863 assert!(expr.is_bin());
3864
3865 let (expr, _) = parse_expr("1 + {}");
3866 assert!(expr.is_bin());
3867 }
3868
3869 #[test]
3870 fn parse_if_expr() {
3871 parse_err(
3872 "fun f() { if true { 1 } else { 2 } * 4 }",
3873 ParseError::ExpectedFactor("*".into()),
3874 1,
3875 36,
3876 );
3877 }
3878
3879 #[test]
3880 fn parse_tuple() {
3881 let (expr, _) = parse_expr("(1,)");
3882 assert_eq!(expr.to_tuple().unwrap().values.len(), 1);
3883
3884 let (expr, _) = parse_expr("(1)");
3885 assert!(expr.is_lit_int());
3886
3887 let (expr, _) = parse_expr("(1,2,3)");
3888 assert_eq!(expr.to_tuple().unwrap().values.len(), 3);
3889
3890 let (expr, _) = parse_expr("(1,2,3,4,)");
3891 assert_eq!(expr.to_tuple().unwrap().values.len(), 4);
3892 }
3893}