Add computation metering to the new stdlib functions

runtime/common/computationkind.go

@@ -57,7 +57,7 @@ const (
 	ComputationKindCreateArrayValue
 	ComputationKindTransferArrayValue
 	ComputationKindDestroyArrayValue
-	_
+	ComputationKindIterateArrayValue
 	_
 	_
 	_

runtime/interpreter/value.go

@@ -2986,6 +2986,9 @@ func (v *ArrayValue) Reverse(
 	count := v.Count()
 	index := count - 1
 
+	// Meter computation for iterating the array.
+	interpreter.ReportComputation(common.ComputationKindIterateArrayValue, uint(v.Count()))
+
 	return NewArrayValueWithIterator(
 		interpreter,
 		v.Type,
@@ -3017,6 +3020,9 @@ func (v *ArrayValue) Filter(
 	procedure FunctionValue,
 ) Value {
 
+	// Meter computation for iterating the array.
+	interpreter.ReportComputation(common.ComputationKindIterateArrayValue, uint(v.Count()))
+
 	elementTypeSlice := []sema.Type{v.semaType.ElementType(false)}
 	iterationInvocation := func(arrayElement Value) Invocation {
 		invocation := NewInvocation(
@@ -3091,6 +3097,9 @@ func (v *ArrayValue) Map(
 	transformFunctionType *sema.FunctionType,
 ) Value {
 
+	// Meter computation for iterating the array.
+	interpreter.ReportComputation(common.ComputationKindIterateArrayValue, uint(v.Count()))
+
 	elementTypeSlice := []sema.Type{v.semaType.ElementType(false)}
 	iterationInvocation := func(arrayElement Value) Invocation {
 		return NewInvocation(

runtime/interpreter/value_string.go

@@ -126,6 +126,9 @@ func stringFunctionJoin(invocation Invocation) Value {
 		panic(errors.NewUnreachableError())
 	}
 
+	// Meter computation for iterating the array.
+	inter.ReportComputation(common.ComputationKindIterateArrayValue, uint(stringArray.Count()))
+
 	// NewStringMemoryUsage already accounts for empty string.
 	common.UseMemory(inter, common.NewStringMemoryUsage(0))
 	var builder strings.Builder

runtime/tests/interpreter/metering_test.go

@@ -397,3 +397,118 @@ func TestInterpretFunctionInvocationHandler(t *testing.T) {
 		occurrences,
 	)
 }
+
+func TestInterpretArrayFunctionsComputationMetering(t *testing.T) {
+
+	t.Parallel()
+
+	t.Run("reverse", func(t *testing.T) {
+		t.Parallel()
+
+		computationMeteredValues := make(map[common.ComputationKind]uint)
+		inter, err := parseCheckAndInterpretWithOptions(t, `
+            fun main() {
+                let x = [1, 2, 3]
+                let y = x.reverse()
+            }`,
+			ParseCheckAndInterpretOptions{
+				Config: &interpreter.Config{
+					OnMeterComputation: func(compKind common.ComputationKind, intensity uint) {
+						computationMeteredValues[compKind] += intensity
+					},
+				},
+			},
+		)
+		require.NoError(t, err)
+
+		_, err = inter.Invoke("main")
+		require.NoError(t, err)
+
+		assert.Equal(t, uint(3), computationMeteredValues[common.ComputationKindIterateArrayValue])
+	})
+
+	t.Run("map", func(t *testing.T) {
+		t.Parallel()
+
+		computationMeteredValues := make(map[common.ComputationKind]uint)
+		inter, err := parseCheckAndInterpretWithOptions(t, `
+            fun main() {
+                let x = [1, 2, 3, 4]
+			    let trueForEven = fun (_ x: Int): Bool {
+					return x % 2 == 0
+				}
+                let y = x.map(trueForEven)
+            }`,
+			ParseCheckAndInterpretOptions{
+				Config: &interpreter.Config{
+					OnMeterComputation: func(compKind common.ComputationKind, intensity uint) {
+						computationMeteredValues[compKind] += intensity
+					},
+				},
+			},
+		)
+		require.NoError(t, err)
+
+		_, err = inter.Invoke("main")
+		require.NoError(t, err)
+
+		assert.Equal(t, uint(4), computationMeteredValues[common.ComputationKindIterateArrayValue])
+	})
+
+	t.Run("filter", func(t *testing.T) {
+		t.Parallel()
+
+		computationMeteredValues := make(map[common.ComputationKind]uint)
+		inter, err := parseCheckAndInterpretWithOptions(t, `
+            fun main() {
+                let x = [1, 2, 3, 4, 5]
+			    let onlyEven = fun (_ x: Int): Bool {
+					return x % 2 == 0
+				}
+                let y = x.filter(onlyEven)
+            }`,
+			ParseCheckAndInterpretOptions{
+				Config: &interpreter.Config{
+					OnMeterComputation: func(compKind common.ComputationKind, intensity uint) {
+						computationMeteredValues[compKind] += intensity
+					},
+				},
+			},
+		)
+		require.NoError(t, err)
+
+		_, err = inter.Invoke("main")
+		require.NoError(t, err)
+
+		assert.Equal(t, uint(5), computationMeteredValues[common.ComputationKindIterateArrayValue])
+	})
+}
+
+func TestInterpretStdlibComputationMetering(t *testing.T) {
+
+	t.Parallel()
+
+	t.Run("string join", func(t *testing.T) {
+		t.Parallel()
+
+		computationMeteredValues := make(map[common.ComputationKind]uint)
+		inter, err := parseCheckAndInterpretWithOptions(t, `
+            fun main() {
+                let s = String.join(["one", "two", "three", "four"], separator: ", ")
+            }`,
+			ParseCheckAndInterpretOptions{
+				Config: &interpreter.Config{
+					OnMeterComputation: func(compKind common.ComputationKind, intensity uint) {
+						computationMeteredValues[compKind] += intensity
+					},
+				},
+			},
+		)
+		require.NoError(t, err)
+
+		_, err = inter.Invoke("main")
+		require.NoError(t, err)
+
+		assert.Equal(t, uint(4), computationMeteredValues[common.ComputationKindIterateArrayValue])
+	})
+}