feat: add if expression ast

Author: gengjiawen

interpreter/lib.rs

@@ -70,12 +70,12 @@ fn eval_expression(expression: &Expression, env: &Env) -> Result<Rc<Object>, Eva
             let right = eval_expression(right, &Rc::clone(env))?;
             return eval_infix(op, &left, &right);
         }
-        Expression::IF(condition, consequence, alternative) => {
+        Expression::IF(IF { condition, consequent, alternate, .. }) => {
             let condition = eval_expression(condition, &Rc::clone(env))?;
             if is_truthy(&condition) {
-                eval_block_statements(&(consequence.0), env)
+                eval_block_statements(&(consequent.0), env)
             } else {
-                match alternative {
+                match alternate {
                     Some(alt) => eval_block_statements(&(alt.0), env),
                     None => Ok(Rc::new(Object::Null))
                 }

parser/ast.rs

@@ -89,7 +89,7 @@ pub enum Expression {
     LITERAL(Literal),
     PREFIX(UnaryExpression),
     INFIX(BinaryExpression),
-    IF(Box<Expression>, BlockStatement, Option<BlockStatement>),
+    IF(IF),
     FUNCTION(Vec<String>, BlockStatement),
     FunctionCall(Box<Expression>, Vec<Expression>), // function can be Identifier or FunctionLiteral (think iife)
     Index(Box<Expression>, Box<Expression>),
@@ -116,6 +116,14 @@ pub struct BinaryExpression {
     pub span: Span,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
+pub struct IF {
+    pub condition: Box<Expression>,
+    pub consequent: BlockStatement,
+    pub alternate: Option<BlockStatement>,
+    pub span: Span,
+}
+
 impl fmt::Display for Expression {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
@@ -127,19 +135,19 @@ impl fmt::Display for Expression {
             Expression::INFIX(BinaryExpression { op, left, right, .. }) => {
                 write!(f, "({} {} {})", left, op.kind, right)
             },
-            Expression::IF(condition, if_block, else_block) => {
-                if let Some(else_block) = else_block {
+            Expression::IF(IF { condition, consequent, alternate, .. }) => {
+                if let Some(else_block) = alternate {
                     write!(f,
                            "if {} {{ {} }} else {{ {} }}",
                            condition,
-                           if_block,
-                           else_block
+                           consequent,
+                           else_block,
                     )
                 } else {
                     write!(f,
                            "if {} {{ {} }}",
                            condition,
-                           if_block,
+                           consequent,
                     )
                 }
             }

parser/ast_tree_test.rs

@@ -54,4 +54,10 @@ mod tests {
         let input = "1 + 2 * 3";
         test_ast_tree("test_binary", input)
     }
+
+    #[test]
+    fn test_if() {
+        let input = "if (x < y) { x } else { y }";
+        test_ast_tree("test_if", input)
+    }
 }

parser/lib.rs

@@ -6,7 +6,7 @@ pub extern crate lexer;
 
 use lexer::token::{TokenKind, Token, Span};
 use lexer::Lexer;
-use crate::ast::{Program, Statement, Expression, Node, Literal, BlockStatement, Let, Integer, Boolean, StringType, Array, Hash, UnaryExpression, BinaryExpression, IDENTIFIER};
+use crate::ast::{Program, Statement, Expression, Node, Literal, BlockStatement, Let, Integer, Boolean, StringType, Array, Hash, UnaryExpression, BinaryExpression, IDENTIFIER, IF};
 use crate::precedences::{Precedence, get_token_precedence};
 
 type ParseError = String;
@@ -268,24 +268,35 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_if_expression(&mut self) -> Result<Expression, ParseError> {
+        let start = self.current_token.span.start;
         self.expect_peek(&TokenKind::LPAREN)?;
         self.next_token();
 
         let condition = self.parse_expression(Precedence::LOWEST)?.0;
         self.expect_peek(&TokenKind::RPAREN)?;
         self.expect_peek(&TokenKind::LBRACE)?;
 
-        let consequence = self.parse_block_statement()?;
+        let consequent = self.parse_block_statement()?;
 
-        let alternative = if self.peek_token_is(&TokenKind::ELSE) {
+        let alternate = if self.peek_token_is(&TokenKind::ELSE) {
             self.next_token();
             self.expect_peek(&TokenKind::LBRACE)?;
             Some(self.parse_block_statement()?)
         } else {
             None
         };
 
-        return Ok(Expression::IF(Box::new(condition), consequence, alternative));
+        let end = self.current_token.span.end;
+
+        return Ok(Expression::IF(IF {
+            condition: Box::new(condition),
+            consequent,
+            alternate,
+            span: Span {
+                start,
+                end,
+            }
+        }));
     }
 
     fn parse_block_statement(&mut self) -> Result<BlockStatement, ParseError> {

parser/snapshots/parser__ast_tree_test__tests__test_if.snap

@@ -0,0 +1,78 @@
+---
+source: parser/ast_tree_test.rs
+expression: let_ast
+---
+{
+  "Program": {
+    "body": [
+      {
+        "type": "Expr",
+        "IF": {
+          "condition": {
+            "INFIX": {
+              "op": {
+                "span": {
+                  "start": 6,
+                  "end": 7
+                },
+                "kind": {
+                  "type": "LT"
+                }
+              },
+              "left": {
+                "IDENTIFIER": {
+                  "name": "x",
+                  "span": {
+                    "start": 4,
+                    "end": 5
+                  }
+                }
+              },
+              "right": {
+                "IDENTIFIER": {
+                  "name": "y",
+                  "span": {
+                    "start": 8,
+                    "end": 9
+                  }
+                }
+              },
+              "span": {
+                "start": 4,
+                "end": 9
+              }
+            }
+          },
+          "consequent": [
+            {
+              "type": "Expr",
+              "IDENTIFIER": {
+                "name": "x",
+                "span": {
+                  "start": 13,
+                  "end": 14
+                }
+              }
+            }
+          ],
+          "alternate": [
+            {
+              "type": "Expr",
+              "IDENTIFIER": {
+                "name": "y",
+                "span": {
+                  "start": 24,
+                  "end": 25
+                }
+              }
+            }
+          ],
+          "span": {
+            "start": 0,
+            "end": 27
+          }
+        }
+      }
+    ]
+  }
+}