feat: Implement lexical scoping for variable resolution and assignment using pre-computed identifier distances and updated environment operations.

Author: walonCode

evaluator/evaluator.go

@@ -16,14 +16,15 @@ import (
 var moduleCache = map[string]*object.Module{}
 
 type Evaluator struct {
-	loopDepth int
+	loopDepth   int
+	Resolutions map[ast.Node]int
 }
 
 func (e *Evaluator) Eval(node ast.Node, env *object.Environment) object.Object {
 	switch node := node.(type) {
 	//statement
 	case *ast.Program:
-		return e.evalProgram(node, *env)
+		return e.evalProgram(node, env)
 	case *ast.ExpressionStatement:
 		return e.Eval(node.Expression, env)
 	case *ast.ReturnStatement:
@@ -138,11 +139,11 @@ func (e *Evaluator) Eval(node ast.Node, env *object.Environment) object.Object {
 		}
 		return evalInfixExpression(node, left, right)
 	case *ast.BlockStatement:
-		return e.evalBlockStatements(node, *env)
+		return e.evalBlockStatements(node, env)
 	case *ast.IfExpression:
-		return e.evalIfExpression(node, *env)
+		return e.evalIfExpression(node, env)
 	case *ast.Identifier:
-		return evalIdentifier(node, env)
+		return e.evalIdentifier(node, env)
 	case *ast.FunctionLiteral:
 		params := node.Parameters
 		body := node.Body
@@ -259,7 +260,7 @@ func (e *Evaluator) evalAssignment(node *ast.InfixExpression, env *object.Enviro
 		if node.Operator == "=" {
 			finalVal = val
 		} else {
-			currentVal := evalIdentifier(left, env)
+			currentVal := e.evalIdentifier(left, env)
 			if isError(currentVal) {
 				return currentVal
 			}
@@ -270,8 +271,11 @@ func (e *Evaluator) evalAssignment(node *ast.InfixExpression, env *object.Enviro
 			return finalVal
 		}
 
-		if isConst, ok := env.Consts[left.Value]; ok && isConst {
-			return object.NewError(node.Line(), node.Column(), "cannot reassign to const: %s", left.Value)
+		if dist, ok := e.Resolutions[left]; ok {
+			if !env.UpdateAt(dist, left.Value, finalVal) {
+				return object.NewError(node.Line(), node.Column(), "cannot reassign to const: %s", left.Value)
+			}
+			return finalVal
 		}
 
 		_, updated := env.Update(left.Value, finalVal)
@@ -626,17 +630,23 @@ func (e *Evaluator) evalExpression(exps []ast.Expression, env *object.Environmen
 	return result
 }
 
-func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object {
+func (e *Evaluator) evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object {
+	if dist, ok := e.Resolutions[node]; ok {
+		if val, ok := env.GetAt(dist, node.Value); ok {
+			return val
+		}
+	}
+
 	if val, ok := env.Get(node.Value); ok {
 		return val
 	}
 	return object.NewError(node.Line(), node.Column(), "identifier not found: %s", node.Value)
 }
 
-func (e *Evaluator) evalProgram(program *ast.Program, env object.Environment) object.Object {
+func (e *Evaluator) evalProgram(program *ast.Program, env *object.Environment) object.Object {
 	var result object.Object
 	for _, statement := range program.Statements {
-		result = e.Eval(statement, &env)
+		result = e.Eval(statement, env)
 
 		switch result := result.(type) {
 		case *object.ReturnValue:
@@ -649,15 +659,16 @@ func (e *Evaluator) evalProgram(program *ast.Program, env object.Environment) ob
 	return result
 }
 
-func (e *Evaluator) evalBlockStatements(block *ast.BlockStatement, env object.Environment) object.Object {
+func (e *Evaluator) evalBlockStatements(block *ast.BlockStatement, env *object.Environment) object.Object {
 	var result object.Object
+	blockEnv := object.NewEnclosedEnvironment(env)
 
 	for _, statement := range block.Statements {
-		result = e.Eval(statement, &env)
+		result = e.Eval(statement, blockEnv)
 
 		if result != nil {
 			rt := result.Type()
-			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ {
+			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ || rt == object.BREAK_OBJ || rt == object.CONTINUE_OBJ {
 				return result
 			}
 		}
@@ -666,29 +677,29 @@ func (e *Evaluator) evalBlockStatements(block *ast.BlockStatement, env object.En
 	return result
 }
 
-func (e *Evaluator) evalIfExpression(node *ast.IfExpression, env object.Environment) object.Object {
-	condition := e.Eval(node.Condition, &env)
+func (e *Evaluator) evalIfExpression(node *ast.IfExpression, env *object.Environment) object.Object {
+	condition := e.Eval(node.Condition, env)
 
 	if isError(condition) {
 		return condition
 	}
 
 	if isTruthy(condition) {
-		return e.Eval(node.Consequence, &env)
+		return e.Eval(node.Consequence, env)
 	}
 
 	for _, v := range node.IfElse {
-		condition := e.Eval(v.Condition, &env)
+		condition := e.Eval(v.Condition, env)
 		if isError(condition) {
 			return condition
 		}
 		if isTruthy(condition) {
-			return e.Eval(v.Consequence, &env)
+			return e.Eval(v.Consequence, env)
 		}
 	}
 
 	if node.Alternative != nil {
-		return e.Eval(node.Alternative, &env)
+		return e.Eval(node.Alternative, env)
 	}
 
 	return object.NULL

evaluator/evaluator_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/walonCode/code-lang/object"
 	"github.com/walonCode/code-lang/parser"
 	"github.com/walonCode/code-lang/std/general"
+	"github.com/walonCode/code-lang/symbol"
 )
 
 func testEval(input string) object.Object {
@@ -21,7 +22,15 @@ func testEval(input string) object.Object {
 		env.Set(name, obj)
 	}
 
-	evaluator := Evaluator{}
+	builder := symbol.NewBuilder()
+	// Pre-populate symbol table with builtins for tests
+	for name := range genMod.Members {
+		builder.Define(name, symbol.FUNCTION)
+	}
+
+	builder.Visit(program)
+
+	evaluator := Evaluator{Resolutions: builder.Resolutions}
 
 	return evaluator.Eval(program, env)
 }

object/environment.go

@@ -54,3 +54,32 @@ func (e *Environment) Update(name string, val Object) (Object, bool) {
 	}
 	return nil, false
 }
+
+func (e *Environment) GetAt(distance int, name string) (Object, bool) {
+	ancestor := e.ancestor(distance)
+	if ancestor == nil {
+		return nil, false
+	}
+	obj, ok := ancestor.Store[name]
+	return obj, ok
+}
+
+func (e *Environment) UpdateAt(distance int, name string, val Object) bool {
+	ancestor := e.ancestor(distance)
+	if ancestor == nil {
+		return false
+	}
+	if isConst, ok := ancestor.Consts[name]; ok && isConst {
+		return false
+	}
+	ancestor.Store[name] = val
+	return true
+}
+
+func (e *Environment) ancestor(distance int) *Environment {
+	curr := e
+	for i := 0; i < distance && curr != nil; i++ {
+		curr = curr.outer
+	}
+	return curr
+}

object/object.go

@@ -32,8 +32,8 @@ const (
 	TIME_OBJ         = "TIME"
 	STRUCT_TYPE      = "STRUCT"
 	STRUCT_INSTANCE  = "STRUCT"
-	BREAK_0BJ = "BREAK"
-	CONTINUE_OBJ = "CONTINUE"
+	BREAK_OBJ        = "BREAK"
+	CONTINUE_OBJ     = "CONTINUE"
 )
 
 // this allows us only to have on Bolean object and Null object
@@ -265,9 +265,11 @@ func (s *StructInstance) Type() ObjectType { return "STRUCT_INSTANCE" }
 func (s *StructInstance) Inspect() string  { return s.TypeName }
 
 type Break struct{}
-func (b *Break) Type() ObjectType { return "STRUCT_INSTANCE" }
+
+func (b *Break) Type() ObjectType { return BREAK_OBJ }
 func (b *Break) Inspect() string  { return "break" }
 
 type Continue struct{}
-func (c *Continue) Type() ObjectType { return "STRUCT_INSTANCE" }
-func (c *Continue) Inspect() string  { return "break" }
+
+func (c *Continue) Type() ObjectType { return CONTINUE_OBJ }
+func (c *Continue) Inspect() string  { return "continue" }

repl/repl.go

@@ -77,7 +77,7 @@ func Start(out io.Writer) {
 			continue
 		}
 
-		evaluator := &evaluator.Evaluator{}
+		evaluator := &evaluator.Evaluator{Resolutions: builder.Resolutions}
 
 		evaluated := evaluator.Eval(programe, env)
 		if evaluated != nil {
@@ -141,7 +141,7 @@ func Execute(source string, out io.Writer) {
 		return
 	}
 
-	evaluator := evaluator.Evaluator{}
+	evaluator := evaluator.Evaluator{Resolutions: builder.Resolutions}
 	evaluated := evaluator.Eval(program, env)
 	if evaluated != nil && evaluated.Type() == object.ERROR_OBJ {
 		io.WriteString(out, evaluated.Inspect())

symbol/builder.go

@@ -7,9 +7,10 @@ import (
 )
 
 type Builder struct {
-	Global  *Scope
-	Current *Scope
-	Errors  []string
+	Global      *Scope
+	Current     *Scope
+	Errors      []string
+	Resolutions map[ast.Node]int
 }
 
 func (b *Builder) error(line, col int, format string, args ...any) {
@@ -19,8 +20,9 @@ func (b *Builder) error(line, col int, format string, args ...any) {
 func NewBuilder() *Builder {
 	global := NewScope("global", nil)
 	return &Builder{
-		Global:  global,
-		Current: global,
+		Global:      global,
+		Current:     global,
+		Resolutions: make(map[ast.Node]int),
 	}
 }
 
@@ -144,8 +146,10 @@ func (b *Builder) VisitExpression(expr ast.Expression) {
 		if e == nil {
 			return
 		}
-		if sym := b.Resolve(e.Value); sym == nil {
+		if _, distance := b.Current.ResolveWithDistance(e.Value); distance == -1 {
 			b.error(e.Line(), e.Column(), "undefined identifier: %s", e.Value)
+		} else {
+			b.Resolutions[e] = distance
 		}
 	case *ast.IntegerLiteral, *ast.Boolean, *ast.StringLiteral, *ast.FloatLiteral, *ast.CharLiteral:
 		// No symbols to define

symbol/scope.go

@@ -1,14 +1,14 @@
 package symbol
 
 type Scope struct {
-	Name string
+	Name    string
 	Parent  *Scope
 	Symbols map[string]*Symbol
 }
 
 func NewScope(name string, parent *Scope) *Scope {
 	return &Scope{
-		Name: name,
+		Name:    name,
 		Parent:  parent,
 		Symbols: make(map[string]*Symbol),
 	}
@@ -26,4 +26,17 @@ func (s *Scope) Resolve(name string) *Symbol {
 		return s.Parent.Resolve(name)
 	}
 	return nil
-}
+}
+
+func (s *Scope) ResolveWithDistance(name string) (*Symbol, int) {
+	distance := 0
+	curr := s
+	for curr != nil {
+		if sym, ok := curr.Symbols[name]; ok {
+			return sym, distance
+		}
+		curr = curr.Parent
+		distance++
+	}
+	return nil, -1
+}