Merge pull request #3779 from onflow/bastian/v1.3-port-internal-fix-3

[v1.3] Port internal fix
onflow · Feb 18, 2025 · deee80b · deee80b
2 parents 03b3b22 + 5592d40
commit deee80b
Show file tree

Hide file tree

Showing 4 changed files with 139 additions and 24 deletions.
diff --git a/activations/activations.go b/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.
 //

diff --git a/interpreter/interpreter.go b/interpreter/interpreter.go
@@ -738,11 +738,10 @@ func (interpreter *Interpreter) VisitFunctionDeclaration(declaration *ast.Functi
 		//         return bar()
 		//     }
 		//
-		// As variable declarations mutate the current activation in place,
-		// push a new activation, so that the mutations are not performed
-		// on the captured activation.
+		// As variable declarations mutate the current activation in place, capture a clone of the current 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

diff --git a/interpreter/interpreter_expression.go b/interpreter/interpreter_expression.go
@@ -1334,11 +1334,10 @@ func (interpreter *Interpreter) VisitFunctionExpression(expression *ast.Function
 	//         return bar()
 	//     }
 	//
-	// As variable declarations mutate the current activation in place,
-	// push a new activation, so that the mutations are not performed
-	// on the captured activation.
+	// As variable declarations mutate the current activation in place, capture a clone of the current activation,
+	// so that the mutations are not performed on the captured activation.
 
-	interpreter.activations.PushNewWithCurrent()
+	lexicalScope = lexicalScope.Clone()
 
 	functionType := interpreter.Program.Elaboration.FunctionExpressionFunctionType(expression)
 

diff --git a/interpreter/misc_test.go b/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,126 @@ func TestInterpretClosureScopingInnerFunction(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(1),
+		interpreter.NewUnmeteredIntValueFromInt64(11),
 		value,
 	)
 }
 
+func TestInterpretClosureScopingFunctionExpressionParameterConfusion(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 TestInterpretClosureScopingInnerFunctionParameterConfusion(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 TestInterpretClosureScopingFunctionExpressionInCall(t *testing.T) {
+	t.Parallel()
+
+	inter := parseCheckAndInterpret(t, `
+        fun foo() {
+            fun() {}
+        }
+
+        fun test(): Int {
+            let a = 1
+            foo()
+            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() {
+            let f = fun() {}
+        }
+
+        fun test(): Int {
+            let a = 1
+            foo()
+            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 +7040,7 @@ func TestInterpretAssignmentAfterClosureFunctionExpression(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(2),
+		interpreter.NewUnmeteredIntValueFromInt64(12),
 		value,
 	)
 }
@@ -6947,11 +7051,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 +7065,7 @@ func TestInterpretAssignmentAfterClosureInnerFunction(t *testing.T) {
 	AssertValuesEqual(
 		t,
 		inter,
-		interpreter.NewUnmeteredIntValueFromInt64(2),
+		interpreter.NewUnmeteredIntValueFromInt64(12),
 		value,
 	)
 }