Refactor to improve iterations

- Use function abstractions (such as map, reduce, filter etc.) over
  for-of loops to gain benefits of having less side effects and easier
  readability.
- Enable `downLevelIterations` for writing modern code with lazy evaluation.
- Refactor for of loops to named abstractions to clearly express their
  intentions without needing to analyse the loop itself.
- Add missing cases for changes that had no tests.

src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts

@@ -47,11 +47,8 @@ interface ICompiledFunctionCall {
 }
 
 function compileCallSequence(context: ICompilationContext): ICompiledFunctionCall {
-  const compiledFunctions = new Array<ICompiledFunctionCall>();
-  for (const call of context.callSequence) {
-    const compiledCode = compileSingleCall(call, context);
-    compiledFunctions.push(...compiledCode);
-  }
+  const compiledFunctions = context.callSequence
+    .flatMap((call) => compileSingleCall(call, context));
   return {
     code: merge(compiledFunctions.map((f) => f.code)),
     revertCode: merge(compiledFunctions.map((f) => f.revertCode)),
@@ -94,14 +91,17 @@ function compileArgs(
   args: IReadOnlyFunctionCallArgumentCollection,
   compiler: IExpressionsCompiler,
 ): IReadOnlyFunctionCallArgumentCollection {
-  const compiledArgs = new FunctionCallArgumentCollection();
-  for (const parameterName of argsToCompile.getAllParameterNames()) {
-    const { argumentValue } = argsToCompile.getArgument(parameterName);
-    const compiledValue = compiler.compileExpressions(argumentValue, args);
-    const newArgument = new FunctionCallArgument(parameterName, compiledValue);
-    compiledArgs.addArgument(newArgument);
-  }
-  return compiledArgs;
+  return argsToCompile
+    .getAllParameterNames()
+    .map((parameterName) => {
+      const { argumentValue } = argsToCompile.getArgument(parameterName);
+      const compiledValue = compiler.compileExpressions(argumentValue, args);
+      return new FunctionCallArgument(parameterName, compiledValue);
+    })
+    .reduce((compiledArgs, arg) => {
+      compiledArgs.addArgument(arg);
+      return compiledArgs;
+    }, new FunctionCallArgumentCollection());
 }
 
 function merge(codeParts: readonly string[]): string {

src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts

@@ -1,4 +1,4 @@
-import { FunctionCallData, FunctionCallsData } from 'js-yaml-loader!@/*';
+import { FunctionCallData, FunctionCallsData, FunctionCallParametersData } from 'js-yaml-loader!@/*';
 import { IFunctionCall } from './IFunctionCall';
 import { FunctionCallArgumentCollection } from './Argument/FunctionCallArgumentCollection';
 import { FunctionCallArgument } from './Argument/FunctionCallArgument';
@@ -26,10 +26,17 @@ function parseFunctionCall(call: FunctionCallData): IFunctionCall {
   if (!call) {
     throw new Error('undefined function call');
   }
-  const args = new FunctionCallArgumentCollection();
-  for (const parameterName of Object.keys(call.parameters || {})) {
-    const arg = new FunctionCallArgument(parameterName, call.parameters[parameterName]);
-    args.addArgument(arg);
-  }
-  return new FunctionCall(call.function, args);
+  const callArgs = parseArgs(call.parameters);
+  return new FunctionCall(call.function, callArgs);
+}
+
+function parseArgs(
+  parameters: FunctionCallParametersData,
+): FunctionCallArgumentCollection {
+  return Object.keys(parameters || {})
+    .map((parameterName) => new FunctionCallArgument(parameterName, parameters[parameterName]))
+    .reduce((args, arg) => {
+      args.addArgument(arg);
+      return args;
+    }, new FunctionCallArgumentCollection());
 }