Fix compiler bug with nested optional arguments

This commit fixes compiler bug where it fails when optional values are
compiled into absent values in nested calls.

- Throw exception with more context for easier future debugging.
- Add better validation of argument values for nested calls.
- Refactor `FunctionCallCompiler` for better clarity and modularize it
  to make it more maintainable and testable.
- Refactor related interface to not have `I` prefix, and
  function/variable names for better clarity.

Context:

Discovered this issue while attempting to call
`RunInlineCodeAsTrustedInstaller` which in turn invokes `RunPowerShell`
for issue #246. This led to the realization that despite parameters
flagged as optional, the nested argument compilation didn't support
them.

tests/unit/shared/Stubs/FunctionCallCompilerStub.ts

@@ -1,29 +1,29 @@
-import { ICompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/ICompiledCode';
-import { IFunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/IFunctionCallCompiler';
+import { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
+import { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
 import { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
-import { IFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/IFunctionCall';
+import { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 
 interface IScenario {
-  calls: IFunctionCall[];
+  calls: FunctionCall[];
   functions: ISharedFunctionCollection;
-  result: ICompiledCode;
+  result: CompiledCode;
 }
 
-export class FunctionCallCompilerStub implements IFunctionCallCompiler {
+export class FunctionCallCompilerStub implements FunctionCallCompiler {
   public scenarios = new Array<IScenario>();
 
   public setup(
-    calls: IFunctionCall[],
+    calls: FunctionCall[],
     functions: ISharedFunctionCollection,
-    result: ICompiledCode,
+    result: CompiledCode,
   ) {
     this.scenarios.push({ calls, functions, result });
   }
 
-  public compileCall(
-    calls: IFunctionCall[],
+  public compileFunctionCalls(
+    calls: readonly FunctionCall[],
     functions: ISharedFunctionCollection,
-  ): ICompiledCode {
+  ): CompiledCode {
     const predefined = this.scenarios
       .find((s) => areEqual(s.calls, calls) && s.functions === functions);
     if (predefined) {
@@ -37,12 +37,12 @@ export class FunctionCallCompilerStub implements IFunctionCallCompiler {
 }
 
 function areEqual(
-  first: readonly IFunctionCall[],
-  second: readonly IFunctionCall[],
+  first: readonly FunctionCall[],
+  second: readonly FunctionCall[],
 ) {
-  const comparer = (a: IFunctionCall, b: IFunctionCall) => a.functionName
+  const comparer = (a: FunctionCall, b: FunctionCall) => a.functionName
     .localeCompare(b.functionName);
-  const printSorted = (calls: readonly IFunctionCall[]) => JSON
+  const printSorted = (calls: readonly FunctionCall[]) => JSON
     .stringify([...calls].sort(comparer));
   return printSorted(first) === printSorted(second);
 }