fix: if span issue

close #47.

Author: gengjiawen

interpreter/lib.rs

@@ -73,10 +73,10 @@ fn eval_expression(expression: &Expression, env: &Env) -> Result<Rc<Object>, Eva
         Expression::IF(IF { condition, consequent, alternate, .. }) => {
             let condition = eval_expression(condition, &Rc::clone(env))?;
             if is_truthy(&condition) {
-                eval_block_statements(&(consequent.0), env)
+                eval_block_statements(&(consequent.body), env)
             } else {
                 match alternate {
-                    Some(alt) => eval_block_statements(&(alt.0), env),
+                    Some(alt) => eval_block_statements(&(alt.body), env),
                     None => Ok(Rc::new(Object::Null))
                 }
             }
@@ -129,7 +129,7 @@ fn apply_function(function: &Rc<Object>, args: &Vec<Rc<Object>>) -> Result<Rc<Ob
                 env.set(param.clone(), args[i].clone());
             });
 
-            let evaluated = eval_block_statements(&body.0, &Rc::new(RefCell::new(env)))?;
+            let evaluated = eval_block_statements(&body.body, &Rc::new(RefCell::new(env)))?;
             return unwrap_return(evaluated);
 
         },

parser/ast.rs

@@ -84,17 +84,15 @@ impl fmt::Display for Statement {
 }
 
 #[derive(Clone, Debug, Eq, Hash, Serialize, Deserialize, PartialEq)]
-pub struct BlockStatement(pub Vec<Statement>);
-
-impl BlockStatement {
-    pub fn new(statements: Vec<Statement>) -> BlockStatement {
-        BlockStatement(statements)
-    }
+#[serde(tag = "type")]
+pub struct BlockStatement {
+    pub body: Vec<Statement>,
+    pub span: Span,
 }
 
 impl fmt::Display for BlockStatement {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "{}", format_statements(&self.0))
+        write!(f, "{}", format_statements(&self.body))
     }
 }
 

parser/lib.rs

@@ -309,6 +309,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_block_statement(&mut self) -> Result<BlockStatement, ParseError> {
+        let start = self.current_token.span.start;
         self.next_token();
         let mut block_statement = Vec::new();
 
@@ -320,7 +321,15 @@ impl<'a> Parser<'a> {
             self.next_token();
         }
 
-        Ok(BlockStatement::new(block_statement))
+        let end = self.current_token.span.end;
+
+        Ok(BlockStatement {
+            body: block_statement,
+            span: Span {
+                start,
+                end,
+            }
+        })
     }
 
     fn parse_fn_expression(&mut self) -> Result<Expression, ParseError> {

parser/snapshots/parser__ast_tree_test__tests__test_func_declaration.snap

@@ -11,16 +11,23 @@ expression: "fn(x) { x };"
         "params": [
           "x"
         ],
-        "body": [
-          {
-            "type": "IDENTIFIER",
-            "name": "x",
-            "span": {
-              "start": 8,
-              "end": 9
+        "body": {
+          "type": "BlockStatement",
+          "body": [
+            {
+              "type": "IDENTIFIER",
+              "name": "x",
+              "span": {
+                "start": 8,
+                "end": 9
+              }
             }
+          ],
+          "span": {
+            "start": 6,
+            "end": 11
           }
-        ],
+        },
         "span": {
           "start": 0,
           "end": 11

parser/snapshots/parser__ast_tree_test__tests__test_if.snap

@@ -40,26 +40,40 @@ expression: "if (x < y) { x } else { y }"
             "end": 9
           }
         },
-        "consequent": [
-          {
-            "type": "IDENTIFIER",
-            "name": "x",
-            "span": {
-              "start": 13,
-              "end": 14
+        "consequent": {
+          "type": "BlockStatement",
+          "body": [
+            {
+              "type": "IDENTIFIER",
+              "name": "x",
+              "span": {
+                "start": 13,
+                "end": 14
+              }
             }
+          ],
+          "span": {
+            "start": 11,
+            "end": 16
           }
-        ],
-        "alternate": [
-          {
-            "type": "IDENTIFIER",
-            "name": "y",
-            "span": {
-              "start": 24,
-              "end": 25
+        },
+        "alternate": {
+          "type": "BlockStatement",
+          "body": [
+            {
+              "type": "IDENTIFIER",
+              "name": "y",
+              "span": {
+                "start": 24,
+                "end": 25
+              }
             }
+          ],
+          "span": {
+            "start": 22,
+            "end": 27
           }
-        ],
+        },
         "span": {
           "start": 0,
           "end": 27