server

internal/evaluator/evaluator.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"monkey/internal/ast"
 	"monkey/internal/builtins"
+	"monkey/internal/context"
 	"monkey/internal/lexer"
 	"monkey/internal/object"
 	"monkey/internal/parser"
@@ -25,37 +26,37 @@ func isError(obj object.Object) bool {
 	return false
 }
 
-func Eval(node ast.Node, env *object.Environment) object.Object {
+func Eval(node ast.Node, ctx context.Context, env *object.Environment) object.Object {
 	switch node := node.(type) {
 
 	// Statements
 	case *ast.Program:
-		return evalProgram(node, env)
+		return evalProgram(node, ctx, env)
 
 	case *ast.ExpressionStatement:
-		return Eval(node.Expression, env)
+		return Eval(node.Expression, ctx, env)
 
 	case *ast.BlockStatement:
-		return evalBlockStatements(node, env)
+		return evalBlockStatements(node, ctx, env)
 
 	case *ast.IfExpression:
-		return evalIfExpression(node, env)
+		return evalIfExpression(node, ctx, env)
 
 	case *ast.WhileExpression:
-		return evalWhileExpression(node, env)
+		return evalWhileExpression(node, ctx, env)
 
 	case *ast.ImportExpression:
-		return evalImportExpression(node, env)
+		return evalImportExpression(node, ctx, env)
 
 	case *ast.ReturnStatement:
-		val := Eval(node.ReturnValue, env)
+		val := Eval(node.ReturnValue, ctx, env)
 		if isError(val) {
 			return val
 		}
 		return object.ReturnValue{Value: val}
 
 	case *ast.BindExpression:
-		value := Eval(node.Value, env)
+		value := Eval(node.Value, ctx, env)
 		if isError(value) {
 			return value
 		}
@@ -72,12 +73,12 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 		return newError("expected identifier on left got=%T", node.Left)
 
 	case *ast.AssignmentExpression:
-		left := Eval(node.Left, env)
+		left := Eval(node.Left, ctx, env)
 		if isError(left) {
 			return left
 		}
 
-		value := Eval(node.Value, env)
+		value := Eval(node.Value, ctx, env)
 		if isError(value) {
 			return value
 		}
@@ -85,13 +86,13 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 		if ident, ok := node.Left.(*ast.Identifier); ok {
 			env.Set(ident.Value, value)
 		} else if ie, ok := node.Left.(*ast.IndexExpression); ok {
-			obj := Eval(ie.Left, env)
+			obj := Eval(ie.Left, ctx, env)
 			if isError(obj) {
 				return obj
 			}
 
 			if array, ok := obj.(*object.Array); ok {
-				index := Eval(ie.Index, env)
+				index := Eval(ie.Index, ctx, env)
 				if isError(index) {
 					return index
 				}
@@ -101,7 +102,7 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 					return newError("cannot index array with %#v", index)
 				}
 			} else if hash, ok := obj.(*object.Hash); ok {
-				key := Eval(ie.Index, env)
+				key := Eval(ie.Index, ctx, env)
 				if isError(key) {
 					return key
 				}
@@ -139,72 +140,72 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 		return NULL
 
 	case *ast.PrefixExpression:
-		right := Eval(node.Right, env)
+		right := Eval(node.Right, ctx, env)
 		if isError(right) {
 			return right
 		}
 		return evalPrefixExpression(node.Operator, right)
 
 	case *ast.InfixExpression:
-		left := Eval(node.Left, env)
+		left := Eval(node.Left, ctx, env)
 		if isError(left) {
 			return left
 		}
-		right := Eval(node.Right, env)
+		right := Eval(node.Right, ctx, env)
 		if isError(right) {
 			return right
 		}
 		return evalInfixExpression(node.Operator, left, right)
 
 	case *ast.CallExpression:
-		function := Eval(node.Function, env)
+		function := Eval(node.Function, ctx, env)
 		if isError(function) {
 			return function
 		}
-		args := evalExpressions(node.Arguments, env)
+		args := evalExpressions(node.Arguments, ctx, env)
 		if len(args) == 1 && isError(args[0]) {
 			return args[0]
 		}
 
-		return applyFunction(function, args)
+		return applyFunction(ctx, function, args)
 
 	case *ast.StringLiteral:
 		return object.String{Value: node.Value}
 
 	case *ast.ArrayLiteral:
-		elements := evalExpressions(node.Elements, env)
+		elements := evalExpressions(node.Elements, ctx, env)
 		if len(elements) == 1 && isError(elements[0]) {
 			return elements[0]
 		}
 		return &object.Array{Elements: elements}
 
 	case *ast.IndexExpression:
-		left := Eval(node.Left, env)
+		left := Eval(node.Left, ctx, env)
 		if isError(left) {
 			return left
 		}
-		index := Eval(node.Index, env)
+		index := Eval(node.Index, ctx, env)
 		if isError(index) {
 			return index
 		}
 		return evalIndexExpression(left, index)
 
 	case *ast.HashLiteral:
-		return evalHashLiteral(node, env)
+		return evalHashLiteral(node, ctx, env)
 
 	}
 
 	return nil
 }
 
-func evalImportExpression(ie *ast.ImportExpression, env *object.Environment) object.Object {
-	name := Eval(ie.Name, env)
+func evalImportExpression(ie *ast.ImportExpression, ctx context.Context, env *object.Environment) object.Object {
+	name := Eval(ie.Name, ctx, env)
 	if isError(name) {
 		return name
 	}
 
 	if s, ok := name.(object.String); ok {
-		attrs := EvalModule(s.Value)
+		attrs := EvalModule(ctx, s.Value)
 		if isError(attrs) {
 			return attrs
 		}
@@ -213,17 +214,17 @@ func evalImportExpression(ie *ast.ImportExpression, env *object.Environment) obj
 	return newError("ImportError: invalid import path '%s'", name)
 }
 
-func evalWhileExpression(we *ast.WhileExpression, env *object.Environment) object.Object {
+func evalWhileExpression(we *ast.WhileExpression, ctx context.Context, env *object.Environment) object.Object {
 	var result object.Object
 
 	for {
-		condition := Eval(we.Condition, env)
+		condition := Eval(we.Condition, ctx, env)
 		if isError(condition) {
 			return condition
 		}
 
 		if isTruthy(condition) {
-			result = Eval(we.Consequence, env)
+			result = Eval(we.Consequence, ctx, env)
 		} else {
 			break
 		}
@@ -236,11 +237,11 @@ func evalWhileExpression(we *ast.WhileExpression, env *object.Environment) objec
 	return NULL
 }
 
-func evalProgram(program *ast.Program, env *object.Environment) object.Object {
+func evalProgram(program *ast.Program, ctx context.Context, env *object.Environment) object.Object {
 	var result object.Object
 
 	for _, statement := range program.Statements {
-		result = Eval(statement, env)
+		result = Eval(statement, ctx, env)
 
 		switch result := result.(type) {
 		case object.ReturnValue:
@@ -254,11 +255,11 @@ func evalProgram(program *ast.Program, env *object.Environment) object.Object {
 	return result
 }
 
-func evalBlockStatements(block *ast.BlockStatement, env *object.Environment) object.Object {
+func evalBlockStatements(block *ast.BlockStatement, ctx context.Context, env *object.Environment) object.Object {
 	var result object.Object
 
 	for _, statement := range block.Statements {
-		result = Eval(statement, env)
+		result = Eval(statement, ctx, env)
 
 		if result != nil {
 			rt := result.Type()
@@ -476,16 +477,16 @@ func evalIntegerInfixExpression(operator string, left, right object.Object) obje
 	}
 }
 
-func evalIfExpression(ie *ast.IfExpression, env *object.Environment) object.Object {
-	condition := Eval(ie.Condition, env)
+func evalIfExpression(ie *ast.IfExpression, ctx context.Context, env *object.Environment) object.Object {
+	condition := Eval(ie.Condition, ctx, env)
 	if isError(condition) {
 		return condition
 	}
 
 	if isTruthy(condition) {
-		return Eval(ie.Consequence, env)
+		return Eval(ie.Consequence, ctx, env)
 	} else if ie.Alternative != nil {
-		return Eval(ie.Alternative, env)
+		return Eval(ie.Alternative, ctx, env)
 	} else {
 		return NULL
 	}
@@ -509,7 +510,7 @@ func newError(format string, a ...interface{}) object.Error {
 }
 
 // EvalModule evaluates the named module and returns a object.Module objec
-func EvalModule(name string) object.Object {
+func EvalModule(ctx context.Context, name string) object.Object {
 	filename := utils.FindModule(name)
 
 	b, err := os.ReadFile(filename)
@@ -526,7 +527,7 @@ func EvalModule(name string) object.Object {
 	}
 
 	env := object.NewEnvironment()
-	Eval(module, env)
+	Eval(module, ctx, env)
 
 	return env.ExportedHash()
 }
@@ -543,11 +544,11 @@ func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object
 	return newError("identifier not found: " + node.Value)
 }
 
-func evalExpressions(exps []ast.Expression, env *object.Environment) []object.Object {
+func evalExpressions(exps []ast.Expression, ctx context.Context, env *object.Environment) []object.Object {
 	var result []object.Object
 
 	for _, e := range exps {
-		evaluated := Eval(e, env)
+		evaluated := Eval(e, ctx, env)
 		if isError(evaluated) {
 			return []object.Object{evaluated}
 		}
@@ -557,16 +558,16 @@ func evalExpressions(exps []ast.Expression, env *object.Environment) []object.Ob
 	return result
 }
 
-func applyFunction(fn object.Object, args []object.Object) object.Object {
+func applyFunction(ctx context.Context, fn object.Object, args []object.Object) object.Object {
 	switch fn := fn.(type) {
 
 	case object.Function:
 		extendedEnv := extendFunctionEnv(fn, args)
-		evaluated := Eval(fn.Body, extendedEnv)
+		evaluated := Eval(fn.Body, ctx, extendedEnv)
 		return unwrapReturnValue(evaluated)
 
 	case object.Builtin:
-		if result := fn.Fn(args...); result != nil {
+		if result := fn.Fn(ctx, args...); result != nil {
 			return result
 		}
 		return NULL
@@ -655,11 +656,11 @@ func evalArrayIndexExpression(array, index object.Object) object.Object {
 	return arrayObject.Elements[idx]
 }
 
-func evalHashLiteral(node *ast.HashLiteral, env *object.Environment) object.Object {
+func evalHashLiteral(node *ast.HashLiteral, ctx context.Context, env *object.Environment) object.Object {
 	pairs := make(map[object.HashKey]object.HashPair)
 
 	for keyNode, valueNode := range node.Pairs {
-		key := Eval(keyNode, env)
+		key := Eval(keyNode, ctx, env)
 		if isError(key) {
 			return key
 		}
@@ -669,7 +670,7 @@ func evalHashLiteral(node *ast.HashLiteral, env *object.Environment) object.Obje
 			return newError("unusable as hash key: %s", key.Type())
 		}
 
-		value := Eval(valueNode, env)
+		value := Eval(valueNode, ctx, env)
 		if isError(value) {
 			return value
 		}