lynxlang/
parser.rs

1use crate::ast::{AstNode, Expression, Precedence, Statement};
2use crate::lexer::Lexer;
3use crate::token::TokenType;
4use std::ops::Deref;
5
6#[derive(Debug)]
7pub struct Parser<'a> {
8    lexer: Lexer<'a>,
9    curToken: TokenType,
10    peekToken: TokenType,
11}
12
13impl<'a> Parser<'a> {
14    fn new(lexer: Lexer) -> Parser {
15        Parser {
16            lexer,
17            curToken: TokenType::NONE,
18            peekToken: TokenType::NONE,
19        }
20    }
21
22    fn next_token(&mut self) {
23        self.curToken = self.peekToken.clone();
24
25        // println!("curToken {:?}", self.curToken);
26
27        self.peekToken = self.lexer.next_token();
28
29        // println!("29 peekToken {:?}", self.peekToken);
30    }
31
32    fn expect_cur_token_is(&self, _t: TokenType) -> bool {
33        let matched = matches!(&self.curToken, _t);
34        // println!("current {:?} {:?} {:?}", &self.curToken, _t, matched);
35
36        matched
37    }
38
39    fn expect_peek_token_is(&self, _t: TokenType) -> bool {
40        let matched = matches!(&self.peekToken, _t);
41        // println!("peek {:?} {:?} {:?}", &self.peekToken, _t, matched);
42
43        matched
44    }
45
46    fn parse_statement(&mut self) -> Option<Statement> {
47        match self.curToken {
48            TokenType::LET => self.parse_let_statement(),
49            TokenType::RETURN => self.parse_return_statement(),
50            _ => self.parse_expression_statement(),
51        }
52    }
53
54    fn parse_expression_statement(&mut self) -> Option<Statement> {
55        let precedence = self.cur_precedence();
56
57        println!("parse_expression_statement {:?} {:?}", self.curToken, precedence);
58
59        match self.parse_expression(precedence) {
60            Some(expr) => {
61                if self.peekToken.eq(&TokenType::SEMICOLON) {
62                    self.next_token();
63                }
64
65                Some(Statement::Expr(Box::new(expr)))
66            }
67            None => None,
68        }
69    }
70
71    fn parse_let_statement(&mut self) -> Option<Statement> {
72        match &self.curToken {
73            TokenType::ASSIGN | TokenType::LET => {
74                self.next_token();
75            }
76            _ => {
77                return None;
78            }
79        }
80
81        let identifier = match &self.curToken {
82            TokenType::IDENTIFIER(name) => Expression::Identifier(name.to_string()),
83            _ => {
84                return None;
85            }
86        };
87
88        if !self.peekToken.eq(&TokenType::ASSIGN) {
89            return None;
90        }
91
92        self.next_token();
93        self.next_token();
94
95        let expression = match self.parse_expression(Precedence::Lowest) {
96            Some(expr) => expr,
97            None => {
98                return None;
99            }
100        };
101
102        if self.peekToken.eq(&TokenType::SEMICOLON) {
103            self.next_token();
104        }
105
106        Some(Statement::Let(Box::new(identifier), Box::new(expression)))
107    }
108
109    fn parse_return_statement(&mut self) -> Option<Statement> {
110        self.next_token();
111
112        let expression = match self.parse_expression(Precedence::Lowest) {
113            Some(expr) => expr,
114            None => {
115                return None;
116            }
117        };
118
119        self.next_token();
120
121        if self.peekToken.eq(&TokenType::SEMICOLON) {
122            self.next_token();
123        }
124
125        Some(Statement::Return(Box::new(expression)))
126    }
127
128    fn parse_boolean_expression(&mut self) -> Option<Expression> {
129        match &self.curToken {
130            TokenType::TRUE => Some(Expression::Boolean(true)),
131            TokenType::FALSE => Some(Expression::Boolean(false)),
132            _ => None,
133        }
134    }
135
136    fn parse_string_expression(&mut self) -> Option<Expression> {
137        match &self.curToken {
138            TokenType::STRING(str) => Some(Expression::String(str.to_string())),
139            _ => None,
140        }
141    }
142
143    fn parse_number_expression(&mut self) -> Option<Expression> {
144        match &self.curToken {
145            &TokenType::NUMBER(num) => Some(Expression::Integer(num)),
146            _ => None,
147        }
148    }
149
150    fn parse_identifier(&mut self) -> Option<Expression> {
151        match &self.curToken {
152            TokenType::IDENTIFIER(name) => {
153                match self.peekToken {
154                    // TokenType::LEFT_PAREN => self.parse_fn_call_expression(name.to_string()),
155                    // TokenType::LEFT_BRACE => {}, // arr[0]
156                    _ => Some(Expression::Identifier(String::from(name))),
157                }
158            }
159            _ => None,
160        }
161    }
162
163    fn parse_expression(&mut self, precedence: Precedence) -> Option<Expression> {
164        let cur_pos = self.lexer.get_cur_pos();
165
166        // prefix expression
167        let mut left = match &self.curToken {
168            TokenType::TRUE => self.parse_boolean_expression(),
169            TokenType::FALSE => self.parse_boolean_expression(),
170            TokenType::STRING(_) => self.parse_string_expression(),
171            &TokenType::NUMBER(_) => self.parse_number_expression(),
172            TokenType::IDENTIFIER(_) => self.parse_identifier(),
173            TokenType::LEFT_BRACE => self.parse_array_expression(),
174            TokenType::LEFT_CURLY_BRACE => self.parse_hash_expression(),
175            TokenType::IF => self.parse_if_expression(),
176            TokenType::WHILE => self.parse_while_expression(),
177            TokenType::BREAK => Some(Expression::Break),
178            TokenType::FN => self.parse_fn_expression(),
179            TokenType::BANG | TokenType::MINUS => self.parse_prefix_expression(),
180            TokenType::LEFT_PAREN => self.parse_grouped_expression(),
181            _ => Some(Expression::NON_PARSED_EXPR((cur_pos, self.curToken.clone()))),
182        };
183
184        println!(
185            "parse_expression {:?} {:?} {:?} {:?}",
186            self.curToken,
187            self.peekToken,
188            precedence < self.peek_precedence(),
189            left
190        );
191
192        // infix expression
193        while !self.peekToken.eq(&TokenType::SEMICOLON) && precedence < self.peek_precedence() {
194            match self.peekToken {
195                TokenType::ADD
196                | TokenType::MINUS
197                | TokenType::MULTIPLY
198                | TokenType::DIVIDE
199                | TokenType::EQUAL_EQUAL
200                | TokenType::LESS
201                | TokenType::LESS_EQUAL
202                | TokenType::GREATER
203                | TokenType::GREATER_EQUAL
204                | TokenType::BANG_EQUAL => {
205                    self.next_token();
206                    left = self.parse_infix_expression(left.unwrap(), &self.curToken.clone());
207                }
208                TokenType::LEFT_PAREN => {
209                    self.next_token();
210                    left = self.parse_fn_call_expression(left.unwrap());
211                }
212                _ => {
213                    return left;
214                }
215            }
216        }
217
218        left
219    }
220
221    fn parse_fn_call_expression(&mut self, func: Expression) -> Option<Expression> {
222        self.next_token();
223
224        if self.curToken.eq(&TokenType::LEFT_PAREN) {
225            self.next_token();
226        }
227
228        let mut fn_parameters = vec![];
229
230        // println!("166 {:?}", self.curToken);
231
232        while !self.curToken.eq(&TokenType::SEMICOLON) {
233            match self.curToken {
234                TokenType::COMMA | TokenType::RIGHT_PAREN => {
235                    self.next_token();
236                }
237                _ => {
238                    let parameter = self.parse_expression(Precedence::Lowest).unwrap();
239
240                    fn_parameters.push(parameter);
241
242                    self.next_token();
243                }
244            }
245        }
246
247        Some(Expression::FnCall(Box::new(func), fn_parameters))
248    }
249
250    fn parse_array_expression(&mut self) -> Option<Expression> {
251        self.next_token();
252
253        let mut expressions = vec![];
254
255        while !self.curToken.eq(&TokenType::RIGHT_BRACE) {
256            match self.curToken {
257                TokenType::COMMA => {
258                    self.next_token();
259                }
260                _ => {
261                    let expression = self.parse_expression(Precedence::Lowest).unwrap();
262
263                    expressions.push(expression);
264
265                    self.next_token();
266                }
267            }
268        }
269
270        Some(Expression::Array(expressions))
271    }
272
273    fn parse_if_expression(&mut self) -> Option<Expression> {
274        self.next_token();
275
276        if self.curToken.eq(&TokenType::LEFT_PAREN) {
277            self.next_token();
278        }
279
280        let ifCondition = match self.parse_expression(Precedence::Lowest) {
281            Some(expr) => expr,
282            None => {
283                return None;
284            }
285        };
286
287        self.next_token();
288
289        if self.curToken.eq(&TokenType::RIGHT_PAREN) {
290            self.next_token();
291        }
292
293        if self.curToken.eq(&TokenType::LEFT_CURLY_BRACE) {
294            self.next_token();
295        }
296
297        let ifStatements = self.parse_block_statements().unwrap();
298
299        if self.curToken.eq(&TokenType::RIGHT_CURLY_BRACE) {
300            self.next_token();
301        }
302
303        // to be refactored
304        let mut elseStatements = vec![];
305
306        if self.curToken.eq(&TokenType::ELSE) {
307            self.next_token();
308
309            while !self.curToken.eq(&TokenType::RIGHT_CURLY_BRACE) {
310                match self.curToken {
311                    TokenType::LEFT_CURLY_BRACE | TokenType::SEMICOLON => {
312                        self.next_token();
313                    }
314                    _ => {
315                        let statement = self.parse_statement().unwrap();
316
317                        elseStatements.push(statement);
318                    }
319                }
320            }
321
322            if self.curToken.eq(&TokenType::RIGHT_CURLY_BRACE) {
323                self.next_token();
324            }
325        }
326
327        Some(Expression::If(
328            Box::new(ifCondition),
329            Statement::BlockStatement(ifStatements),
330            if !elseStatements.is_empty() {
331                Some(Statement::BlockStatement(elseStatements))
332            } else {
333                Option::None
334            },
335        ))
336    }
337
338    fn parse_while_expression(&mut self) -> Option<Expression> {
339        self.next_token();
340
341        if self.curToken.eq(&TokenType::LEFT_PAREN) {
342            self.next_token();
343        }
344
345        let whileCondition = match self.parse_expression(Precedence::Lowest) {
346            Some(expr) => expr,
347            None => {
348                return None;
349            }
350        };
351
352        self.next_token();
353
354        if self.curToken.eq(&TokenType::RIGHT_PAREN) {
355            self.next_token();
356        }
357
358        if self.curToken.eq(&TokenType::LEFT_CURLY_BRACE) {
359            self.next_token();
360        }
361
362        let whileStatements = self.parse_block_statements().unwrap();
363
364        Some(Expression::While(
365            Box::new(whileCondition),
366            Statement::BlockStatement(whileStatements),
367        ))
368    }
369
370    fn parse_let_fn_expression(&mut self) -> Option<Expression> {
371        // function literal does not have function name
372        let fn_name = Expression::Identifier(String::from(""));
373
374        self.next_token();
375
376        if self.curToken.eq(&TokenType::LEFT_PAREN) {
377            self.next_token();
378        }
379
380        let mut fn_parameters = vec![];
381
382        while !self.curToken.eq(&TokenType::RIGHT_PAREN) {
383            match self.curToken {
384                TokenType::COMMA => {
385                    self.next_token();
386                }
387                _ => {
388                    let parameter = self.parse_expression(Precedence::Lowest).unwrap();
389
390                    fn_parameters.push(parameter);
391
392                    self.next_token();
393                }
394            }
395        }
396
397        if self.curToken.eq(&TokenType::RIGHT_PAREN) {
398            self.next_token();
399        }
400
401        if self.curToken.eq(&TokenType::LEFT_CURLY_BRACE) {
402            self.next_token();
403        }
404
405        let fn_body = self.parse_block_statements().unwrap();
406
407        Some(Expression::Fn(
408            Box::new(fn_name),
409            fn_parameters,
410            Statement::BlockStatement(fn_body),
411        ))
412    }
413
414    fn parse_fn_expression(&mut self) -> Option<Expression> {
415        // let foo = fn() {}
416        if self.peekToken.eq(&TokenType::LEFT_PAREN) {
417            return self.parse_let_fn_expression();
418        }
419
420        self.next_token();
421
422        let fn_name = match &self.curToken {
423            TokenType::IDENTIFIER(name) => Expression::Identifier(String::from(name)),
424            _ => {
425                return None;
426            }
427        };
428
429        self.next_token();
430
431        if self.curToken.eq(&TokenType::LEFT_PAREN) {
432            self.next_token();
433        }
434
435        let mut fn_parameters = vec![];
436
437        while !self.curToken.eq(&TokenType::RIGHT_PAREN) {
438            match self.curToken {
439                TokenType::COMMA => {
440                    self.next_token();
441                }
442                _ => {
443                    let parameter = self.parse_expression(Precedence::Lowest).unwrap();
444
445                    fn_parameters.push(parameter);
446
447                    self.next_token();
448                }
449            }
450        }
451
452        if self.curToken.eq(&TokenType::RIGHT_PAREN) {
453            self.next_token();
454        }
455
456        if self.curToken.eq(&TokenType::LEFT_CURLY_BRACE) {
457            self.next_token();
458        }
459
460        let fn_body = self.parse_block_statements().unwrap();
461
462        Some(Expression::Fn(
463            Box::new(fn_name),
464            fn_parameters,
465            Statement::BlockStatement(fn_body),
466        ))
467    }
468
469    fn parse_block_statements(&mut self) -> Option<Vec<Statement>> {
470        let mut block_statements = vec![];
471
472        while !self.curToken.eq(&TokenType::RIGHT_CURLY_BRACE) {
473            match self.curToken {
474                TokenType::SEMICOLON => {
475                    self.next_token();
476                }
477                _ => {
478                    let statement = self.parse_statement().unwrap();
479
480                    block_statements.push(statement);
481                }
482            }
483        }
484
485        Some(block_statements)
486    }
487
488    fn parse_hash_expression(&mut self) -> Option<Expression> {
489        self.next_token();
490
491        let mut flat_hash_vec = vec![];
492
493        while !self.curToken.eq(&TokenType::RIGHT_CURLY_BRACE) {
494            match self.curToken {
495                TokenType::COLON => {
496                    self.next_token();
497                }
498                TokenType::COMMA => {
499                    self.next_token();
500                }
501                TokenType::LEFT_BRACE => {
502                    let hash_value = self.parse_expression(Precedence::Lowest).unwrap();
503                    flat_hash_vec.push(hash_value);
504
505                    self.next_token();
506                }
507                _ => {
508                    // { key: value, ... }
509                    match &self.peekToken {
510                        TokenType::COLON => {
511                            let hash_key = self.parse_expression(Precedence::Lowest).unwrap();
512                            flat_hash_vec.push(hash_key);
513
514                            self.next_token();
515                        }
516                        TokenType::COMMA => {
517                            let hash_value = self.parse_expression(Precedence::Lowest).unwrap();
518                            flat_hash_vec.push(hash_value);
519
520                            self.next_token();
521                        }
522                        TokenType::RIGHT_CURLY_BRACE => {
523                            let hash_value = self.parse_expression(Precedence::Lowest).unwrap();
524                            flat_hash_vec.push(hash_value);
525                            self.next_token();
526                            break;
527                        }
528                        _ => {
529                            self.next_token();
530                        }
531                    }
532                }
533            }
534        }
535
536        println!("445 {:?}", flat_hash_vec);
537
538        let mut hash_tuple = vec![];
539
540        // https://stackoverflow.com/questions/66386013/how-to-iterate-over-two-elements-in-a-collection-stepping-by-one-using-iterator
541        // let mut hash_tuple = flat_hash_vec
542        //     .windows(2)
543        //     .map(|&w: Windows<&[Expression; 2]>| (*w.nth(0), *w.nth(1)))
544        //     .collect();
545
546        let mut chunks = flat_hash_vec.chunks(2);
547
548        while !chunks.is_empty() {
549            if let [hash_key, hash_value] = chunks.next().unwrap() {
550                hash_tuple.push((hash_key.deref().clone(), hash_value.deref().clone()));
551            }
552        }
553
554        Some(Expression::Hash(hash_tuple))
555    }
556
557    fn cur_precedence(&self) -> Precedence {
558        Precedence::get(&self.curToken)
559    }
560
561    fn peek_precedence(&self) -> Precedence {
562        Precedence::get(&self.peekToken)
563    }
564
565    fn parse_prefix_expression(&mut self) -> Option<Expression> {
566        println!("parse_prefix_expression {:?}", self.curToken);
567
568        let operator = self.curToken.clone();
569        self.next_token();
570
571        // match self.parse_expression(Precedence::Prefix) {
572        //     Some(expr) => Some(Expression::Prefix(operator, Box::new(expr))),
573        //     None => None,
574        // }
575        self.parse_expression(Precedence::Prefix)
576            .map(|expr| Expression::Prefix(operator, Box::new(expr)))
577    }
578
579    fn parse_infix_expression(&mut self, left: Expression, token: &TokenType) -> Option<Expression> {
580        let cur_precedence = self.cur_precedence();
581
582        self.next_token();
583
584        match self.parse_expression(cur_precedence) {
585            Some(expr) => {
586                println!("parse_infix_expression {:?}", self.curToken);
587
588                Some(Expression::Infix(Box::new(left), token.clone(), Box::new(expr)))
589            }
590            None => None,
591        }
592    }
593
594    fn parse_grouped_expression(&mut self) -> Option<Expression> {
595        self.next_token();
596
597        // println!("parse_grouped_expression {:?}", self.curToken);
598
599        let expr = self.parse_expression(Precedence::Lowest);
600
601        // )
602        if !self.peekToken.eq(&TokenType::RIGHT_PAREN) {
603            None
604        } else {
605            self.next_token();
606            expr
607        }
608    }
609
610    pub fn get(input: &str) -> Parser {
611        let lexer = Lexer::new(input);
612
613        Parser::new(lexer)
614    }
615
616    pub fn parse_program(&mut self) -> AstNode {
617        self.next_token();
618        self.next_token();
619
620        let mut statements = vec![];
621
622        // while let Some(ended) = self.lexer.is_end() {
623        //     if ended {
624        //         break;
625        //     } else {
626        //         match self.parse_statement() {
627        //             Some(statement) => {
628        //                 statements.push(statement);
629        //             }
630        //             _ => {}
631        //         }
632        //         self.next_token();
633        //     }
634        // }
635
636        while !self.curToken.eq(&TokenType::EOF) {
637            if let Some(statement) = self.parse_statement() {
638                statements.push(statement);
639            }
640            self.next_token();
641        }
642
643        AstNode::Program(statements)
644    }
645}
646
647#[cfg(test)]
648mod unit_test {
649    use crate::ast::{AstNode, Expression, Precedence, Statement};
650    use crate::parser::Parser;
651    use crate::token::TokenType;
652
653    fn get_parser(input: &str) -> Parser {
654        return Parser::get(input);
655    }
656
657    #[test]
658    fn parse_let_statement() {
659        let input = r#"
660            let version = 1234;
661            let name = "Lynx programming language";
662            let is_cool = false;
663        "#;
664        let mut parser = get_parser(input);
665        let rootNode = parser.parse_program();
666
667        let expected = AstNode::Program(vec![
668            Statement::Let(
669                Box::new(Expression::Identifier(String::from("version"))),
670                Box::new(Expression::Integer(1234)),
671            ),
672            Statement::Let(
673                Box::new(Expression::Identifier(String::from("name"))),
674                Box::new(Expression::String(String::from("Lynx programming language"))),
675            ),
676            Statement::Let(
677                Box::new(Expression::Identifier(String::from("is_cool"))),
678                Box::new(Expression::Boolean(false)),
679            ),
680        ]);
681
682        // println!("{:?}", rootNode);
683
684        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
685    }
686
687    #[test]
688    fn parse_return_statement() {
689        let input = r#"
690            return 1234;
691            return "Lynx programming language";
692            return false;
693            return foo_456;
694        "#;
695        let mut parser = get_parser(input);
696        let rootNode = parser.parse_program();
697
698        let expected = AstNode::Program(vec![
699            Statement::Return(Box::new(Expression::Integer(1234))),
700            Statement::Return(Box::new(Expression::String(String::from("Lynx programming language")))),
701            Statement::Return(Box::new(Expression::Boolean(false))),
702            Statement::Return(Box::new(Expression::Identifier(String::from("foo_456")))),
703        ]);
704
705        println!("{:?}", rootNode);
706
707        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
708    }
709
710    #[test]
711    fn parse_integer_expression() {
712        let input = r#"1234"#;
713        let mut parser = get_parser(input);
714        let rootNode = parser.parse_program();
715
716        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Integer(1234)))]);
717
718        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
719    }
720
721    #[test]
722    fn parse_string_expression() {
723        let input = r#""foo""#;
724        let mut parser = get_parser(input);
725        let rootNode = parser.parse_program();
726
727        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::String(String::from("foo"))))]);
728
729        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
730    }
731
732    #[test]
733    fn parse_boolean_expression() {
734        let input = r#"true"#;
735        let mut parser = get_parser(input);
736        let rootNode = parser.parse_program();
737
738        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Boolean(true)))]);
739
740        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
741    }
742
743    #[test]
744    fn parse_array_expression() {
745        let input = r#"
746            [1234, true, "Lynx programming language", [1234, true, "Lynx programming language"]];
747        "#;
748        let mut parser = get_parser(input);
749        let rootNode = parser.parse_program();
750
751        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Array(vec![
752            Expression::Integer(1234),
753            Expression::Boolean(true),
754            Expression::String(String::from("Lynx programming language")),
755            Expression::Array(vec![
756                Expression::Integer(1234),
757                Expression::Boolean(true),
758                Expression::String(String::from("Lynx programming language")),
759            ]),
760        ])))]);
761
762        println!("{:?}", rootNode);
763
764        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
765    }
766
767    #[test]
768    fn parse_hash_expression() {
769        let input = r#"
770            {
771                "foo": "bar",
772                1: 2,
773                2: [4, "stuff", false],
774                "abc": true
775            };
776        "#;
777        let mut parser = get_parser(input);
778        let rootNode = parser.parse_program();
779
780        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Hash(vec![
781            (
782                Expression::String(String::from("foo")),
783                Expression::String(String::from("bar")),
784            ),
785            (Expression::Integer(1), Expression::Integer(2)),
786            (
787                Expression::Integer(2),
788                Expression::Array(vec![
789                    Expression::Integer(4),
790                    Expression::String(String::from("stuff")),
791                    Expression::Boolean(false),
792                ]),
793            ),
794            (Expression::String(String::from("abc")), Expression::Boolean(true)),
795        ])))]);
796
797        println!("{:?}", rootNode);
798
799        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
800    }
801
802    #[test]
803    fn parse_prefix_expression() {
804        let input = r#"
805            !true;
806            !false;
807        "#;
808        let mut parser = get_parser(input);
809        let rootNode = parser.parse_program();
810        // -2; // todo minus
811
812        let expected = AstNode::Program(vec![
813            Statement::Expr(Box::new(Expression::Prefix(
814                TokenType::BANG,
815                Box::new(Expression::Boolean(true)),
816            ))),
817            Statement::Expr(Box::new(Expression::Prefix(
818                TokenType::BANG,
819                Box::new(Expression::Boolean(false)),
820            ))),
821        ]);
822
823        println!("{:?}", rootNode);
824
825        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
826    }
827
828    #[test]
829    fn parse_infix_expression() {
830        let input = r#"
831            1 + 2 / 3 * 4 - 5;
832        "#;
833        // println!("input {:?}", input);
834
835        let mut parser = get_parser(input);
836        let rootNode = parser.parse_program();
837
838        let _tree_like_representation = r#"
839            Expr(
840                Infix(
841                    Infix(
842                        Integer(1), 
843                            ADD, 
844                        Infix(
845                            Infix(
846                                Integer(2), 
847                                DIVIDE, 
848                                Integer(3)
849                            ), 
850                            MULTIPLY, 
851                            Integer(4))
852                        )
853                    ), 
854                    MINUS, 
855                    Integer(5))
856                )
857            )        
858        "#;
859
860        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Infix(
861            Box::new(Expression::Infix(
862                Box::new(Expression::Integer(1)),
863                TokenType::ADD,
864                Box::new(Expression::Infix(
865                    Box::new(Expression::Infix(
866                        Box::new(Expression::Integer(2)),
867                        TokenType::DIVIDE,
868                        Box::new(Expression::Integer(3)),
869                    )),
870                    TokenType::MULTIPLY,
871                    Box::new(Expression::Integer(4)),
872                )),
873            )),
874            TokenType::MINUS,
875            Box::new(Expression::Integer(5)),
876        )))]);
877
878        println!("{:?}", rootNode);
879
880        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
881    }
882
883    #[test]
884    fn parse_let_infix_expression() {
885        let input = r#"
886            let foo = 1 + 2 / 3 * 4 - 5;
887        "#;
888        // println!("input {:?}", input);
889
890        let mut parser = get_parser(input);
891        let rootNode = parser.parse_program();
892
893        let expected = AstNode::Program(vec![Statement::Let(
894            Box::new(Expression::Identifier(String::from("foo"))),
895            Box::new(Expression::Infix(
896                Box::new(Expression::Infix(
897                    Box::new(Expression::Integer(1)),
898                    TokenType::ADD,
899                    Box::new(Expression::Infix(
900                        Box::new(Expression::Infix(
901                            Box::new(Expression::Integer(2)),
902                            TokenType::DIVIDE,
903                            Box::new(Expression::Integer(3)),
904                        )),
905                        TokenType::MULTIPLY,
906                        Box::new(Expression::Integer(4)),
907                    )),
908                )),
909                TokenType::MINUS,
910                Box::new(Expression::Integer(5)),
911            )),
912        )]);
913
914        println!("{:?}", rootNode);
915
916        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
917    }
918
919    #[test]
920    fn parse_grouped_expression() {
921        let input = r#"
922         3 / (1 + 2);
923        "#;
924        // todo fix (1 + 2) / 3;
925        let mut parser = get_parser(input);
926        let rootNode = parser.parse_program();
927
928        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Infix(
929            Box::new(Expression::Integer(3)),
930            TokenType::DIVIDE,
931            Box::new(Expression::Infix(
932                Box::new(Expression::Integer(1)),
933                TokenType::ADD,
934                Box::new(Expression::Integer(2)),
935            )),
936        )))]);
937
938        println!("{:?}", rootNode);
939
940        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
941    }
942
943    #[test]
944    fn parse_if_expression() {
945        let input = r#"
946            if (foo) {
947                let bar = "stuff";
948                return bar;
949            } else {
950                return 5;
951            }
952        "#;
953        let mut parser = get_parser(input);
954        let rootNode = parser.parse_program();
955
956        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::If(
957            Box::new(Expression::Identifier(String::from("foo"))),
958            Statement::BlockStatement(vec![
959                Statement::Let(
960                    Box::new(Expression::Identifier(String::from("bar"))),
961                    Box::new(Expression::String(String::from("stuff"))),
962                ),
963                Statement::Return(Box::new(Expression::Identifier(String::from("bar")))),
964            ]),
965            Some(Statement::BlockStatement(vec![Statement::Return(Box::new(
966                Expression::Integer(5),
967            ))])),
968        )))]);
969
970        println!("{:?}", rootNode);
971
972        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
973    }
974
975    #[test]
976    fn parse_while_expression() {
977        let input = r#"
978            while (foo) {
979                let bar = "stuff";
980
981                foo(bar);
982            }
983        "#;
984        let mut parser = get_parser(input);
985        let rootNode = parser.parse_program();
986
987        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::While(
988            Box::new(Expression::Identifier(String::from("foo"))),
989            Statement::BlockStatement(vec![
990                Statement::Let(
991                    Box::new(Expression::Identifier(String::from("bar"))),
992                    Box::new(Expression::String(String::from("stuff"))),
993                ),
994                Statement::Expr(Box::new(Expression::FnCall(
995                    Box::new(Expression::Identifier(String::from("foo"))),
996                    vec![Expression::Identifier(String::from("bar"))],
997                ))),
998            ]),
999        )))]);
1000
1001        println!("{:?}", rootNode);
1002
1003        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1004    }
1005
1006    #[test]
1007    fn parse_while_break_expression() {
1008        let input = r#"
1009            while (foo) {
1010                let bar = "stuff";
1011
1012                foo(bar);
1013                break;
1014            }
1015        "#;
1016        let mut parser = get_parser(input);
1017        let rootNode = parser.parse_program();
1018
1019        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::While(
1020            Box::new(Expression::Identifier(String::from("foo"))),
1021            Statement::BlockStatement(vec![
1022                Statement::Let(
1023                    Box::new(Expression::Identifier(String::from("bar"))),
1024                    Box::new(Expression::String(String::from("stuff"))),
1025                ),
1026                Statement::Expr(Box::new(Expression::FnCall(
1027                    Box::new(Expression::Identifier(String::from("foo"))),
1028                    vec![Expression::Identifier(String::from("bar"))],
1029                ))),
1030                Statement::Expr(Box::new(Expression::Break)),
1031            ]),
1032        )))]);
1033
1034        println!("{:?}", rootNode);
1035
1036        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1037    }
1038
1039    #[test]
1040    fn parse_fn_expression() {
1041        let input = r#"
1042            fn foo("bar", stuff, 123) {
1043                let another_bar = stuff;
1044                return another_bar;
1045            }
1046        "#;
1047        let mut parser = get_parser(input);
1048        let rootNode = parser.parse_program();
1049
1050        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::Fn(
1051            Box::new(Expression::Identifier(String::from("foo"))),
1052            vec![
1053                Expression::String(String::from("bar")),
1054                Expression::Identifier(String::from("stuff")),
1055                Expression::Integer(123),
1056            ],
1057            Statement::BlockStatement(vec![
1058                Statement::Let(
1059                    Box::new(Expression::Identifier(String::from("another_bar"))),
1060                    Box::new(Expression::Identifier(String::from("stuff"))),
1061                ),
1062                Statement::Return(Box::new(Expression::Identifier(String::from("another_bar")))),
1063            ]),
1064        )))]);
1065
1066        println!("{:?}", rootNode);
1067
1068        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1069    }
1070
1071    #[test]
1072    fn parse_let_fn_expression() {
1073        let input = r#"
1074            let foo = fn("bar", stuff, 123) {
1075                let another_bar = stuff;
1076                return another_bar;
1077            }
1078        "#;
1079        let mut parser = get_parser(input);
1080        let rootNode = parser.parse_program();
1081
1082        let expected = AstNode::Program(vec![Statement::Let(
1083            Box::new(Expression::Identifier(String::from("foo"))),
1084            Box::new(Expression::Fn(
1085                Box::new(Expression::Identifier(String::from(""))),
1086                vec![
1087                    Expression::String(String::from("bar")),
1088                    Expression::Identifier(String::from("stuff")),
1089                    Expression::Integer(123),
1090                ],
1091                Statement::BlockStatement(vec![
1092                    Statement::Let(
1093                        Box::new(Expression::Identifier(String::from("another_bar"))),
1094                        Box::new(Expression::Identifier(String::from("stuff"))),
1095                    ),
1096                    Statement::Return(Box::new(Expression::Identifier(String::from("another_bar")))),
1097                ]),
1098            )),
1099        )]);
1100
1101        println!("{:?}", rootNode);
1102
1103        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1104    }
1105
1106    #[test]
1107    fn parse_fn_call_expression() {
1108        let input = r#"
1109            let arr = foo("bar", another_bar, 456);
1110        "#;
1111        let mut parser = get_parser(input);
1112        let rootNode = parser.parse_program();
1113
1114        let expected = AstNode::Program(vec![Statement::Let(
1115            Box::new(Expression::Identifier(String::from("arr"))),
1116            Box::new(Expression::FnCall(
1117                Box::new(Expression::Identifier(String::from("foo"))),
1118                vec![
1119                    Expression::String(String::from("bar")),
1120                    Expression::Identifier(String::from("another_bar")),
1121                    Expression::Integer(456),
1122                ],
1123            )),
1124        )]);
1125
1126        println!("{:?}", rootNode);
1127
1128        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1129    }
1130
1131    #[test]
1132    fn parse_builtin_expression() {
1133        let input = r#"
1134            first([1, 2, 3]);
1135        "#;
1136        let mut parser = get_parser(input);
1137        let rootNode = parser.parse_program();
1138
1139        let expected = AstNode::Program(vec![Statement::Expr(Box::new(Expression::FnCall(
1140            Box::new(Expression::Identifier(String::from("first"))),
1141            vec![Expression::Array(vec![
1142                Expression::Integer(1),
1143                Expression::Integer(2),
1144                Expression::Integer(3),
1145            ])],
1146        )))]);
1147
1148        println!("{:?}", rootNode);
1149
1150        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1151    }
1152
1153    #[test]
1154    fn parse_fibonacci() {
1155        let input = r#"
1156            fn fibonacci(x) {
1157                if (x == 0) {
1158                    return 0;
1159                } else {
1160                    return 1;
1161                }
1162            }
1163            let foo = 123;
1164            let fib_val = fibonacci(foo);
1165            fib_val;
1166        "#;
1167        let mut parser = get_parser(input);
1168        let rootNode = parser.parse_program();
1169        println!("{:?}", rootNode);
1170
1171        // let expected = AstNode::Program(vec![Statement::Let(
1172        //     Box::new(Expression::Identifier(String::from("arr"))),
1173        //     Box::new(Expression::FnCall(
1174        //         Box::new(Expression::Identifier(String::from("foo"))),
1175        //         vec![
1176        //             Expression::String(String::from("bar")),
1177        //             Expression::Identifier(String::from("another_bar")),
1178        //             Expression::Integer(456),
1179        //         ],
1180        //     )),
1181        // )]);
1182
1183        // assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1184        assert_eq!(1, 1);
1185    }
1186
1187    #[test]
1188    fn check_precedence() {
1189        let mut parser = get_parser(
1190            r#"
1191        (foo + bar / 123)
1192    "#,
1193        );
1194
1195        parser.next_token();
1196        assert_eq!(Precedence::Group, parser.peek_precedence());
1197
1198        parser.next_token();
1199        assert_eq!(Precedence::Lowest, parser.peek_precedence());
1200
1201        parser.next_token();
1202        assert_eq!(Precedence::Addition, parser.peek_precedence());
1203
1204        parser.next_token();
1205        parser.next_token();
1206        assert_eq!(Precedence::Multiply, parser.peek_precedence());
1207    }
1208
1209    #[test]
1210    fn parse_program() {
1211        let input = r#"
1212            let version = 1234;
1213            let name = "Lynx programming language";
1214            let is_cool = false;
1215            let arr = [1234, true, "Lynx programming language", [1234, true, "Lynx programming language"]];            
1216            let hash = {
1217                "foo": "bar",
1218                1: 2,
1219                2: [4, "stuff", false],
1220                "abc": true
1221            };
1222            let prefix = !true;
1223            let infix = 1 + 2 / 3 * 4 - 5;
1224            let grouped = 3 / (1 + 2);
1225            
1226            fn foo("bar", stuff, 123) {
1227                let another_bar = stuff;
1228                return another_bar;
1229            }
1230
1231            let call_val = foo("bar", another_bar, 456);
1232            
1233            while (call_val) {
1234                let bar = "stuff";
1235
1236                foo(bar, call_val);
1237            }
1238            
1239            if (call_val) {
1240                let bar = "stuff";
1241                return bar;
1242            } else {
1243                return 5;
1244            }
1245        "#;
1246        let mut parser = get_parser(input);
1247        let rootNode = parser.parse_program();
1248
1249        let expected = AstNode::Program(vec![
1250            Statement::Let(
1251                Box::new(Expression::Identifier(String::from("version"))),
1252                Box::new(Expression::Integer(1234)),
1253            ),
1254            Statement::Let(
1255                Box::new(Expression::Identifier(String::from("name"))),
1256                Box::new(Expression::String(String::from("Lynx programming language"))),
1257            ),
1258            Statement::Let(
1259                Box::new(Expression::Identifier(String::from("is_cool"))),
1260                Box::new(Expression::Boolean(false)),
1261            ),
1262            Statement::Let(
1263                Box::new(Expression::Identifier(String::from("arr"))),
1264                Box::new(Expression::Array(vec![
1265                    Expression::Integer(1234),
1266                    Expression::Boolean(true),
1267                    Expression::String(String::from("Lynx programming language")),
1268                    Expression::Array(vec![
1269                        Expression::Integer(1234),
1270                        Expression::Boolean(true),
1271                        Expression::String(String::from("Lynx programming language")),
1272                    ]),
1273                ])),
1274            ),
1275            Statement::Let(
1276                Box::new(Expression::Identifier(String::from("hash"))),
1277                Box::new(Expression::Hash(vec![
1278                    (
1279                        Expression::String(String::from("foo")),
1280                        Expression::String(String::from("bar")),
1281                    ),
1282                    (Expression::Integer(1), Expression::Integer(2)),
1283                    (
1284                        Expression::Integer(2),
1285                        Expression::Array(vec![
1286                            Expression::Integer(4),
1287                            Expression::String(String::from("stuff")),
1288                            Expression::Boolean(false),
1289                        ]),
1290                    ),
1291                    (Expression::String(String::from("abc")), Expression::Boolean(true)),
1292                ])),
1293            ),
1294            Statement::Let(
1295                Box::new(Expression::Identifier(String::from("prefix"))),
1296                Box::new(Expression::Prefix(TokenType::BANG, Box::new(Expression::Boolean(true)))),
1297            ),
1298            Statement::Let(
1299                Box::new(Expression::Identifier(String::from("infix"))),
1300                Box::new(Expression::Infix(
1301                    Box::new(Expression::Infix(
1302                        Box::new(Expression::Integer(1)),
1303                        TokenType::ADD,
1304                        Box::new(Expression::Infix(
1305                            Box::new(Expression::Infix(
1306                                Box::new(Expression::Integer(2)),
1307                                TokenType::DIVIDE,
1308                                Box::new(Expression::Integer(3)),
1309                            )),
1310                            TokenType::MULTIPLY,
1311                            Box::new(Expression::Integer(4)),
1312                        )),
1313                    )),
1314                    TokenType::MINUS,
1315                    Box::new(Expression::Integer(5)),
1316                )),
1317            ),
1318            Statement::Let(
1319                Box::new(Expression::Identifier(String::from("grouped"))),
1320                Box::new(Expression::Infix(
1321                    Box::new(Expression::Integer(3)),
1322                    TokenType::DIVIDE,
1323                    Box::new(Expression::Infix(
1324                        Box::new(Expression::Integer(1)),
1325                        TokenType::ADD,
1326                        Box::new(Expression::Integer(2)),
1327                    )),
1328                )),
1329            ),
1330            Statement::Expr(Box::new(Expression::Fn(
1331                Box::new(Expression::Identifier(String::from("foo"))),
1332                vec![
1333                    Expression::String(String::from("bar")),
1334                    Expression::Identifier(String::from("stuff")),
1335                    Expression::Integer(123),
1336                ],
1337                Statement::BlockStatement(vec![
1338                    Statement::Let(
1339                        Box::new(Expression::Identifier(String::from("another_bar"))),
1340                        Box::new(Expression::Identifier(String::from("stuff"))),
1341                    ),
1342                    Statement::Return(Box::new(Expression::Identifier(String::from("another_bar")))),
1343                ]),
1344            ))),
1345            Statement::Let(
1346                Box::new(Expression::Identifier(String::from("call_val"))),
1347                Box::new(Expression::FnCall(
1348                    Box::new(Expression::Identifier(String::from("foo"))),
1349                    vec![
1350                        Expression::String(String::from("bar")),
1351                        Expression::Identifier(String::from("another_bar")),
1352                        Expression::Integer(456),
1353                    ],
1354                )),
1355            ),
1356            Statement::Expr(Box::new(Expression::While(
1357                Box::new(Expression::Identifier(String::from("call_val"))),
1358                Statement::BlockStatement(vec![
1359                    Statement::Let(
1360                        Box::new(Expression::Identifier(String::from("bar"))),
1361                        Box::new(Expression::String(String::from("stuff"))),
1362                    ),
1363                    Statement::Expr(Box::new(Expression::FnCall(
1364                        Box::new(Expression::Identifier(String::from("foo"))),
1365                        vec![
1366                            Expression::Identifier(String::from("bar")),
1367                            Expression::Identifier(String::from("call_val")),
1368                        ],
1369                    ))),
1370                ]),
1371            ))),
1372            Statement::Expr(Box::new(Expression::If(
1373                Box::new(Expression::Identifier(String::from("call_val"))),
1374                Statement::BlockStatement(vec![
1375                    Statement::Let(
1376                        Box::new(Expression::Identifier(String::from("bar"))),
1377                        Box::new(Expression::String(String::from("stuff"))),
1378                    ),
1379                    Statement::Return(Box::new(Expression::Identifier(String::from("bar")))),
1380                ]),
1381                Some(Statement::BlockStatement(vec![Statement::Return(Box::new(
1382                    Expression::Integer(5),
1383                ))])),
1384            ))),
1385        ]);
1386
1387        println!("{:?}", rootNode);
1388
1389        assert_eq!(format!("{:?}", rootNode), format!("{:?}", expected));
1390    }
1391}
lynxlang/parser.rs

lynxlang/
parser.rs
