instead of pushing an additional activation, capture a clone of the current activation

pushing an additional activation would also have to get popped at the end
of the function call to ensure the activation stack stays balanced

Author: turbolent

activations/activations.go

@@ -107,6 +107,19 @@ func (a *Activation[T]) Set(name string, value T) {
 	a.entries[name] = value
 }
 
+func (a *Activation[T]) Clone() *Activation[T] {
+	clone := NewActivation[T](a.MemoryGauge, a.Parent)
+
+	if a.entries != nil {
+		clone.entries = make(map[string]T, len(a.entries))
+		for name, value := range a.entries { //nolint:maprange
+			clone.entries[name] = value
+		}
+	}
+
+	return clone
+}
+
 // Activations is a stack of activation records.
 // Each entry represents a new activation record.
 //

interpreter/interpreter.go

@@ -742,7 +742,7 @@ func (interpreter *Interpreter) VisitFunctionDeclaration(declaration *ast.Functi
 		// push a new activation, so that the mutations are not performed
 		// on the captured activation.
 
-		interpreter.activations.PushNewWithCurrent()
+		lexicalScope = lexicalScope.Clone()
 	}
 
 	// make the function itself available inside the function

interpreter/interpreter_expression.go

@@ -1338,7 +1338,7 @@ func (interpreter *Interpreter) VisitFunctionExpression(expression *ast.Function
 	// push a new activation, so that the mutations are not performed
 	// on the captured activation.
 
-	interpreter.activations.PushNewWithCurrent()
+	lexicalScope = lexicalScope.Clone()
 
 	functionType := interpreter.Program.Elaboration.FunctionExpressionFunctionType(expression)
 

interpreter/misc_test.go

@@ -6869,11 +6869,11 @@ func TestInterpretClosureScopingFunctionExpression(t *testing.T) {
 
 	inter := parseCheckAndInterpret(t, `
         fun test(a: Int): Int {
-            let bar = fun(): Int {
-                return a
+            let bar = fun(b: Int): Int {
+                return a + b
             }
             let a = 2
-            return bar()
+            return bar(b: 10)
         }
     `)
 
@@ -6885,7 +6885,7 @@ func TestInterpretClosureScopingFunctionExpression(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(1),
+		interpreter.NewUnmeteredIntValueFromInt64(11),
 		actual,
 	)
 }
@@ -6895,11 +6895,11 @@ func TestInterpretClosureScopingInnerFunction(t *testing.T) {
 
 	inter := parseCheckAndInterpret(t, `
         fun test(a: Int): Int {
-            fun bar(): Int {
-                return a
+            fun bar(b: Int): Int {
+                return a + b
             }
             let a = 2
-            return bar()
+            return bar(b: 10)
         }
     `)
 
@@ -6911,22 +6911,74 @@ func TestInterpretClosureScopingInnerFunction(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(1),
+		interpreter.NewUnmeteredIntValueFromInt64(11),
 		value,
 	)
 }
 
+func TestInterpretClosureScopingFunctionExpressionInCall(t *testing.T) {
+	t.Parallel()
+
+	inter := parseCheckAndInterpret(t, `
+        fun foo(a: Int) {
+            fun() {}
+        }
+
+        fun test(): Int {
+            let a = 1
+            foo(a: 2)
+            return a
+        }
+    `)
+
+	actual, err := inter.Invoke("test")
+	require.NoError(t, err)
+
+	AssertValuesEqual(
+		t,
+		inter,
+		interpreter.NewUnmeteredIntValueFromInt64(1),
+		actual,
+	)
+}
+
+func TestInterpretClosureScopingInnerFunctionInCall(t *testing.T) {
+	t.Parallel()
+
+	inter := parseCheckAndInterpret(t, `
+        fun foo(a: Int) {
+            let f = fun() {}
+        }
+
+        fun test(): Int {
+            let a = 1
+            foo(a: 2)
+            return a
+        }
+    `)
+
+	actual, err := inter.Invoke("test")
+	require.NoError(t, err)
+
+	AssertValuesEqual(
+		t,
+		inter,
+		interpreter.NewUnmeteredIntValueFromInt64(1),
+		actual,
+	)
+}
+
 func TestInterpretAssignmentAfterClosureFunctionExpression(t *testing.T) {
 	t.Parallel()
 
 	inter := parseCheckAndInterpret(t, `
         fun test(): Int {
             var a = 1
-            let bar = fun(): Int {
-                return a
+            let bar = fun(b: Int): Int {
+                return a + b
             }
             a = 2
-            return bar()
+            return bar(b: 10)
         }
     `)
 
@@ -6936,7 +6988,7 @@ func TestInterpretAssignmentAfterClosureFunctionExpression(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(2),
+		interpreter.NewUnmeteredIntValueFromInt64(12),
 		value,
 	)
 }
@@ -6947,11 +6999,11 @@ func TestInterpretAssignmentAfterClosureInnerFunction(t *testing.T) {
 	inter := parseCheckAndInterpret(t, `
         fun test(): Int {
             var a = 1
-            fun bar(): Int {
-                return a
+            fun bar(b: Int): Int {
+                return a + b
             }
             a = 2
-            return bar()
+            return bar(b: 10)
         }
     `)
 
@@ -6961,7 +7013,7 @@ func TestInterpretAssignmentAfterClosureInnerFunction(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(2),
+		interpreter.NewUnmeteredIntValueFromInt64(12),
 		value,
 	)
 }