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

@@ -2996,6 +2996,9 @@ func (v *ArrayValue) Reverse(
 				return nil
 			}
 
+			// Meter computation for iterating the array.
+			interpreter.ReportComputation(common.ComputationKindIterateArrayValue, 1)
+
 			value := v.Get(interpreter, locationRange, index)
 			index--
 
@@ -3046,6 +3049,9 @@ func (v *ArrayValue) Filter(
 			var value Value
 
 			for {
+				// Meter computation for iterating the array.
+				interpreter.ReportComputation(common.ComputationKindIterateArrayValue, 1)
+
 				atreeValue, err := iterator.Next()
 				if err != nil {
 					panic(errors.NewExternalError(err))
@@ -3139,6 +3145,9 @@ func (v *ArrayValue) Map(
 		uint64(v.Count()),
 		func() Value {
 
+			// Meter computation for iterating the array.
+			interpreter.ReportComputation(common.ComputationKindIterateArrayValue, 1)
+
 			atreeValue, err := iterator.Next()
 			if err != nil {
 				panic(errors.NewExternalError(err))

runtime/interpreter/value_string.go

@@ -132,6 +132,10 @@ func stringFunctionJoin(invocation Invocation) Value {
 	first := true
 
 	stringArray.Iterate(inter, func(element Value) (resume bool) {
+
+		// Meter computation for iterating the array.
+		inter.ReportComputation(common.ComputationKindIterateArrayValue, 1)
+
 		// Add separator
 		if !first {
 			// Construct directly instead of using NewStringMemoryUsage to avoid

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(5), 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(6), 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])
+	})
+}