feat: integrate environment management in interpreter and parser for block statements

Author: shubhdevelop

Interpreter/interpreter.go

@@ -10,9 +10,10 @@ import (
 	"github.com/shubhdevelop/Lox/environment"
 )
 
-type Interpreter struct{}
+type Interpreter struct {
+	Environment *environment.Environment
+}
 
-var env = environment.NewEnvironment()
 var _ ast.ExprVisitor = (*Interpreter)(nil)
 var _ ast.StmtVisitor = (*Interpreter)(nil)
 
@@ -214,17 +215,35 @@ func (i *Interpreter) VisitVarStmtStmt(stmt ast.VarStmt) interface{} {
 		value = i.evaluate(stmt.Initializer)
 	}
 
-	env.Define(stmt.Name.Lexeme, value)
+	i.Environment.Define(stmt.Name.Lexeme, value)
 	return nil
 }
 
 func (i *Interpreter) VisitVariableExpr(expr ast.Variable) interface{} {
-	value, _ := env.Get(expr.Name)
+	value, _ := i.Environment.Get(expr.Name)
 	return value
 }
 
 func (i *Interpreter) VisitAssignExpr(expr ast.Assign) interface{} {
 	value := i.evaluate(expr.Value)
-	env.Assign(expr.Name, value)
+	i.Environment.Assign(expr.Name, value)
 	return value
 }
+
+func (i *Interpreter) VisitBlockStmtStmt(stmt ast.BlockStmt) interface{} {
+	i.executeBlock(stmt.Statement, environment.NewEnclosedEnvironment(i.Environment))
+	return nil
+}
+
+func (i *Interpreter) executeBlock(statements []ast.Stmt, environment *environment.Environment) {
+	previous := i.Environment
+	defer func() {
+		// ensures environment is restored, like Java's finally
+		i.Environment = previous
+	}()
+
+	i.Environment = environment
+	for _, stmt := range statements {
+		i.execute(stmt)
+	}
+}

Lox.go

@@ -7,16 +7,19 @@ import (
 	"os"
 
 	interpreter "github.com/shubhdevelop/Lox/Interpreter"
-	"github.com/shubhdevelop/Lox/parser"
 	"github.com/shubhdevelop/Lox/Scanner"
+	"github.com/shubhdevelop/Lox/environment"
+	"github.com/shubhdevelop/Lox/parser"
 	"github.com/shubhdevelop/Lox/state"
 )
 
 func run(source string) {
 	state.HadError = false // Reset error state
 	scanner := scanner.Scanner{Source: source}
 	tokens, err := scanner.ScanTokens()
-	interpreter := interpreter.Interpreter{}
+	interpreter := interpreter.Interpreter{
+		environment.NewEnvironment(),
+	}
 	parserInstance := parser.Parser{
 		Tokens: tokens,
 	}

parser/parser.go

@@ -237,9 +237,21 @@ func (p *Parser) statement() ast.Stmt {
 	if p.match(token.PRINT) {
 		return p.printStatement()
 	}
+	if p.match(token.LEFT_BRACE) {
+		return ast.BlockStmt{p.block()}
+	}
 	return p.expressionStatement()
 }
 
+func (p *Parser) block() []ast.Stmt {
+	statements := []ast.Stmt{}
+	for !p.check(token.RIGHT_BRACE) && !p.isAtEnd() {
+		statements = append(statements, p.declaration())
+	}
+	p.consume(token.RIGHT_BRACE, "Expect '}' after block.")
+	return statements
+}
+
 func (p *Parser) printStatement() ast.Stmt {
 	value := p.expression()
 	p.consume(token.SEMICOLON, "Expect ';' after value.")