♻️ refactor ast with a box to BlockStatement

src/ast.rs

@@ -19,7 +19,7 @@ pub enum Expression {
     IfExpression {
         condition: Box<Expression>,
         consequence: Box<BlockStatement>,
-        alternative: Option<BlockStatement>,
+        alternative: Option<Box<BlockStatement>>,
     },
     FunctionExpression {
         parameters: Vec<Token>,

src/parser.rs

@@ -100,10 +100,7 @@ impl Parser {
             return None;
         }
 
-        Some(AstNode::Statement(Box::new(Statement::LetStatement {
-            name,
-            value,
-        })))
+        Some(AstNode::Statement(Box::new(Statement::LetStatement { name, value })))
     }
 
     fn parse_expression_statement(&mut self) -> Option<AstNode> {
@@ -129,9 +126,7 @@ impl Parser {
 
         let expression = Box::new(self.parse_expression(Precedence::Lowest)?);
 
-        Some(AstNode::Statement(Box::new(Statement::ReturnStatement(
-            expression,
-        ))))
+        Some(AstNode::Statement(Box::new(Statement::ReturnStatement(expression))))
     }
 
     fn parse_expression(&mut self, precedence: Precedence) -> Option<Expression> {
@@ -300,9 +295,9 @@ impl Parser {
         let alternative = match self.current_token {
             Token::Else => {
                 self.advance_tokens();
-                self.parse_block_statement()
-            }
-            _ => None,
+                Some(Box::new(self.parse_block_statement()?))
+            },
+            _ => None
         };
 
         Some(Expression::IfExpression {

tests/parser.rs

@@ -333,11 +333,11 @@ fn given_an_if_else_expression_it_should_parse_correctly() {
                 "x".to_string(),
             )))],
         }),
-        alternative: Some(BlockStatement {
+        alternative: Some(Box::new(BlockStatement {
             statements: vec![AstNode::Expression(Box::new(Expression::Identifier(
                 "y".to_string(),
             )))],
-        }),
+        })),
     };
 
     let parsed_program = parser.parse_program();