add blocks to interpreter

src/interpreter.rs

@@ -13,7 +13,14 @@ impl Interpreter {
     pub fn build_interpreter(instance: crate::Lox) -> Interpreter {
         Interpreter {
             instance: instance,
-            environment: Environment::build_envrionment(instance)
+            environment: Environment::build_environment(instance)
+        }
+    }
+
+    // Interpret an expression
+    pub fn interpret(&mut self, statements: Vec<Stmt>) {
+        for statement in statements {
+            self.execute(statement)
         }
     }
 
@@ -67,15 +74,19 @@ impl Interpreter {
         }
     }
 
-    // Interpret an expression
-    pub fn interpret(&mut self, statements: Vec<Stmt>) {
+    fn execute_block(&mut self, statements: Vec<Stmt>, environment: Environment) {
+        let previous: Environment = self.environment.clone();
+        self.environment = environment;
+
         for statement in statements {
-            self.execute(statement)
+            self.execute(statement);
         }
+
+        self.environment = previous;
     }
 }
 
-impl StmtVisitor<()> for Interpreter {
+impl StmtVisitor<> for Interpreter {
     fn visit_expression(&mut self, expression: Expr) {
         self.visit(expression);
     }
@@ -107,6 +118,11 @@ impl StmtVisitor<()> for Interpreter {
             }
         }
     }
+
+    fn visit_block(&mut self, statements: Vec<Stmt>) {
+        self.execute_block(statements, Environment::build_environment(self.instance));
+        return
+    }
 }
 
 // See ExprVisitor at Expression for implementation requirements

src/parser.rs

@@ -223,7 +223,7 @@ impl Parser {
     fn block(&mut self) -> Vec<Stmt>{
         let mut statements: Vec<Stmt> = Vec::new();
 
-        while !(self.check(TokenType::RBrace)) && !self.is_end() {
+        while !self.check(TokenType::RBrace) && !self.is_end() {
             if let Some(a) = self.declaration() {
                 statements.push(a);
             } 
@@ -265,13 +265,13 @@ impl Parser {
         let name: Option<Token> = self.consume(TokenType::Id, "Expect variable name.".to_string());
         match name {
             Some(a) => {
-                let mut initalizer: Option<Expr> = None;
+                let mut initializer: Option<Expr> = None;
                 if self.match_type(vec![TokenType::Equal]) {
-                    initalizer = Some(self.expression());
+                    initializer = Some(self.expression());
                 }
 
                 let _a: Option<Token> = self.consume(TokenType::Semicolon, "Expect ';' after variable decleration.".to_string());
-                return Some(Stmt::Var{name: a, right: initalizer})
+                return Some(Stmt::Var{name: a, right: initializer})
             },
             None => return None
         }