Refactor to enforce strictNullChecks

This commit applies `strictNullChecks` to the entire codebase to improve
maintainability and type safety. Key changes include:

- Remove some explicit null-checks where unnecessary.
- Add necessary null-checks.
- Refactor static factory functions for a more functional approach.
- Improve some test names and contexts for better debugging.
- Add unit tests for any additional logic introduced.
- Refactor `createPositionFromRegexFullMatch` to its own function as the
  logic is reused.
- Prefer `find` prefix on functions that may return `undefined` and
  `get` prefix for those that always return a value.

src/application/Parser/Script/CategoryCollectionParseContext.ts

@@ -17,8 +17,7 @@ export class CategoryCollectionParseContext implements ICategoryCollectionParseC
     scripting: IScriptingDefinition,
     syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
   ) {
-    if (!scripting) { throw new Error('missing scripting'); }
     this.syntax = syntaxFactory.create(scripting.language);
-    this.compiler = new ScriptCompiler(functionsData, this.syntax);
+    this.compiler = new ScriptCompiler(functionsData ?? [], this.syntax);
   }
 }

src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts

@@ -15,19 +15,10 @@ export class Expression implements IExpression {
     public readonly evaluator: ExpressionEvaluator,
     parameters?: IReadOnlyFunctionParameterCollection,
   ) {
-    if (!position) {
-      throw new Error('missing position');
-    }
-    if (!evaluator) {
-      throw new Error('missing evaluator');
-    }
     this.parameters = parameters ?? new FunctionParameterCollection();
   }
 
   public evaluate(context: IExpressionEvaluationContext): string {
-    if (!context) {
-      throw new Error('missing context');
-    }
     validateThatAllRequiredParametersAreSatisfied(this.parameters, context.args);
     const args = filterUnusedArguments(this.parameters, context.args);
     const filteredContext = new ExpressionEvaluationContext(args, context.pipelineCompiler);

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts

@@ -12,8 +12,5 @@ export class ExpressionEvaluationContext implements IExpressionEvaluationContext
     public readonly args: IReadOnlyFunctionCallArgumentCollection,
     public readonly pipelineCompiler: IPipelineCompiler = new PipelineCompiler(),
   ) {
-    if (!args) {
-      throw new Error('missing args, send empty collection instead.');
-    }
   }
 }

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts

@@ -0,0 +1,16 @@
+import { ExpressionPosition } from './ExpressionPosition';
+
+export function createPositionFromRegexFullMatch(
+  match: RegExpMatchArray,
+): ExpressionPosition {
+  const startPos = match.index;
+  if (startPos === undefined) {
+    throw new Error(`Regex match did not yield any results: ${JSON.stringify(match)}`);
+  }
+  const fullMatch = match[0];
+  if (!fullMatch.length) {
+    throw new Error(`Regex match is empty: ${JSON.stringify(match)}`);
+  }
+  const endPos = startPos + fullMatch.length;
+  return new ExpressionPosition(startPos, endPos);
+}

src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts

@@ -11,14 +11,11 @@ export class ExpressionsCompiler implements IExpressionsCompiler {
   ) { }
 
   public compileExpressions(
-    code: string | undefined,
+    code: string,
     args: IReadOnlyFunctionCallArgumentCollection,
   ): string {
-    if (!args) {
-      throw new Error('missing args, send empty collection instead.');
-    }
     if (!code) {
-      return code;
+      return '';
     }
     const context = new ExpressionEvaluationContext(args);
     const compiledCode = compileRecursively(code, context, this.extractor);
@@ -145,7 +142,7 @@ function ensureParamsUsedInCodeHasArgsProvided(
   providedArgs: IReadOnlyFunctionCallArgumentCollection,
 ): void {
   const usedParameterNames = extractRequiredParameterNames(expressions);
-  if (!usedParameterNames?.length) {
+  if (!usedParameterNames.length) {
     return;
   }
   const notProvidedParameters = usedParameterNames

src/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler.ts

@@ -2,6 +2,7 @@ import { IReadOnlyFunctionCallArgumentCollection } from '../Function/Call/Argume
 
 export interface IExpressionsCompiler {
   compileExpressions(
-    code: string | undefined,
-    args: IReadOnlyFunctionCallArgumentCollection): string;
+    code: string,
+    args: IReadOnlyFunctionCallArgumentCollection,
+  ): string;
 }

src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts

@@ -10,12 +10,9 @@ const Parsers = [
 
 export class CompositeExpressionParser implements IExpressionParser {
   public constructor(private readonly leafs: readonly IExpressionParser[] = Parsers) {
-    if (!leafs) {
+    if (!leafs.length) {
       throw new Error('missing leafs');
     }
-    if (leafs.some((leaf) => !leaf)) {
-      throw new Error('missing leaf');
-    }
   }
 
   public findExpressions(code: string): IExpression[] {

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts

@@ -1,9 +1,9 @@
 import { IExpressionParser } from '../IExpressionParser';
-import { ExpressionPosition } from '../../Expression/ExpressionPosition';
 import { IExpression } from '../../Expression/IExpression';
 import { Expression, ExpressionEvaluator } from '../../Expression/Expression';
 import { IFunctionParameter } from '../../../Function/Parameter/IFunctionParameter';
 import { FunctionParameterCollection } from '../../../Function/Parameter/FunctionParameterCollection';
+import { createPositionFromRegexFullMatch } from '../../Expression/ExpressionPositionFactory';
 
 export abstract class RegexParser implements IExpressionParser {
   protected abstract readonly regex: RegExp;
@@ -21,7 +21,7 @@ export abstract class RegexParser implements IExpressionParser {
     const matches = code.matchAll(this.regex);
     for (const match of matches) {
       const primitiveExpression = this.buildExpression(match);
-      const position = this.doOrRethrow(() => createPosition(match), 'invalid script position', code);
+      const position = this.doOrRethrow(() => createPositionFromRegexFullMatch(match), 'invalid script position', code);
       const parameters = createParameters(primitiveExpression);
       const expression = new Expression(position, primitiveExpression.evaluator, parameters);
       yield expression;
@@ -37,12 +37,6 @@ export abstract class RegexParser implements IExpressionParser {
   }
 }
 
-function createPosition(match: RegExpMatchArray): ExpressionPosition {
-  const startPos = match.index;
-  const endPos = startPos + match[0].length;
-  return new ExpressionPosition(startPos, endPos);
-}
-
 function createParameters(
   expression: IPrimitiveExpression,
 ): FunctionParameterCollection {

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.ts

@@ -28,7 +28,7 @@ function hasLines(text: string) {
 */
 function inlineComments(code: string): string {
   const makeInlineComment = (comment: string) => {
-    const value = comment?.trim();
+    const value = comment.trim();
     if (!value) {
       return '<##>';
     }

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.ts

@@ -15,12 +15,6 @@ export class PipeFactory implements IPipeFactory {
   private readonly pipes = new Map<string, IPipe>();
 
   constructor(pipes: readonly IPipe[] = RegisteredPipes) {
-    if (!pipes) {
-      throw new Error('missing pipes');
-    }
-    if (pipes.some((pipe) => !pipe)) {
-      throw new Error('missing pipe in list');
-    }
     for (const pipe of pipes) {
       this.registerPipe(pipe);
     }
@@ -28,10 +22,11 @@ export class PipeFactory implements IPipeFactory {
 
   public get(pipeName: string): IPipe {
     validatePipeName(pipeName);
-    if (!this.pipes.has(pipeName)) {
+    const pipe = this.pipes.get(pipeName);
+    if (!pipe) {
       throw new Error(`Unknown pipe: "${pipeName}"`);
     }
-    return this.pipes.get(pipeName);
+    return pipe;
   }
 
   private registerPipe(pipe: IPipe): void {

src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/WithParser.ts

@@ -5,6 +5,7 @@ import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function
 import { IExpression } from '../Expression/IExpression';
 import { ExpressionPosition } from '../Expression/ExpressionPosition';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
+import { createPositionFromRegexFullMatch } from '../Expression/ExpressionPositionFactory';
 
 export class WithParser implements IExpressionParser {
   public findExpressions(code: string): IExpression[] {
@@ -42,31 +43,25 @@ function parseAllWithExpressions(
     expressions.push({
       type: WithStatementType.Start,
       parameterName: match[1],
-      position: createPosition(match),
+      position: createPositionFromRegexFullMatch(match),
     });
   }
   for (const match of input.matchAll(WithStatementEndRegEx)) {
     expressions.push({
       type: WithStatementType.End,
-      position: createPosition(match),
+      position: createPositionFromRegexFullMatch(match),
     });
   }
   for (const match of input.matchAll(ContextVariableWithPipelineRegEx)) {
     expressions.push({
       type: WithStatementType.ContextVariable,
-      position: createPosition(match),
+      position: createPositionFromRegexFullMatch(match),
       pipeline: match[1],
     });
   }
   return expressions;
 }
 
-function createPosition(match: RegExpMatchArray): ExpressionPosition {
-  const startPos = match.index;
-  const endPos = startPos + match[0].length;
-  return new ExpressionPosition(startPos, endPos);
-}
-
 class WithStatementBuilder {
   private readonly contextVariables = new Array<{
     readonly positionInScope: ExpressionPosition;
@@ -125,7 +120,7 @@ class WithStatementBuilder {
 
   private substituteContextVariables(
     scope: string,
-    substituter: (pipeline: string) => string,
+    substituter: (pipeline?: string) => string,
   ): string {
     if (!this.contextVariables.length) {
       return scope;
@@ -157,7 +152,7 @@ function parseWithExpressions(input: string): IExpression[] {
     .sort((a, b) => b.position.start - a.position.start);
   const expressions = new Array<IExpression>();
   const builders = new Array<WithStatementBuilder>();
-  const throwWithContext = (message: string) => {
+  const throwWithContext = (message: string): never => {
     throw new Error(`${message}\n${buildErrorContext(input, allStatements)}}`);
   };
   while (sortedStatements.length > 0) {
@@ -178,12 +173,15 @@ function parseWithExpressions(input: string): IExpression[] {
         }
         builders[builders.length - 1].addContextVariable(statement.position, statement.pipeline);
         break;
-      case WithStatementType.End:
-        if (builders.length === 0) {
+      case WithStatementType.End: {
+        const builder = builders.pop();
+        if (!builder) {
           throwWithContext('Redundant `end` statement, missing `with`?');
+          break;
         }
-        expressions.push(builders.pop().buildExpression(statement.position, input));
+        expressions.push(builder.buildExpression(statement.position, input));
         break;
+      }
     }
   }
   if (builders.length > 0) {

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts

@@ -5,9 +5,6 @@ export class FunctionCallArgumentCollection implements IFunctionCallArgumentColl
   private readonly arguments = new Map<string, IFunctionCallArgument>();
 
   public addArgument(argument: IFunctionCallArgument): void {
-    if (!argument) {
-      throw new Error('missing argument');
-    }
     if (this.hasArgument(argument.parameterName)) {
       throw new Error(`argument value for parameter ${argument.parameterName} is already provided`);
     }

src/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/NewlineCodeSegmentMerger.ts

@@ -3,18 +3,22 @@ import { CodeSegmentMerger } from './CodeSegmentMerger';
 
 export class NewlineCodeSegmentMerger implements CodeSegmentMerger {
   public mergeCodeParts(codeSegments: readonly CompiledCode[]): CompiledCode {
-    if (!codeSegments?.length) {
+    if (!codeSegments.length) {
       throw new Error('missing segments');
     }
     return {
       code: joinCodeParts(codeSegments.map((f) => f.code)),
-      revertCode: joinCodeParts(codeSegments.map((f) => f.revertCode)),
+      revertCode: joinCodeParts(
+        codeSegments
+          .map((f) => f.revertCode)
+          .filter((code): code is string => Boolean(code)),
+      ),
     };
   }
 }
 
 function joinCodeParts(codeSegments: readonly string[]): string {
   return codeSegments
-    .filter((segment) => segment?.length > 0)
+    .filter((segment) => segment.length > 0)
     .join('\n');
 }

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

@@ -21,9 +21,7 @@ export class FunctionCallSequenceCompiler implements FunctionCallCompiler {
     calls: readonly FunctionCall[],
     functions: ISharedFunctionCollection,
   ): CompiledCode {
-    if (!functions) { throw new Error('missing functions'); }
-    if (!calls?.length) { throw new Error('missing calls'); }
-    if (calls.some((f) => !f)) { throw new Error('missing function call'); }
+    if (!calls.length) { throw new Error('missing calls'); }
     const context: FunctionCallCompilationContext = {
       allFunctions: functions,
       rootCallSequence: calls,

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/InlineFunctionCallCompiler.ts

@@ -1,6 +1,6 @@
 import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
 import { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
-import { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { FunctionBodyType, ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
 import { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
@@ -12,19 +12,33 @@ export class InlineFunctionCallCompiler implements SingleCallCompilerStrategy {
   }
 
   public canCompile(func: ISharedFunction): boolean {
-    return func.body.code !== undefined;
+    return func.body.type === FunctionBodyType.Code;
   }
 
   public compileFunction(
     calledFunction: ISharedFunction,
     callToFunction: FunctionCall,
   ): CompiledCode[] {
+    if (calledFunction.body.type !== FunctionBodyType.Code) {
+      throw new Error([
+        'Unexpected function body type.',
+        `\tExpected: "${FunctionBodyType[FunctionBodyType.Code]}"`,
+        `\tActual: "${FunctionBodyType[calledFunction.body.type]}"`,
+        'Function:',
+        `\t${JSON.stringify(callToFunction)}`,
+      ].join('\n'));
+    }
     const { code } = calledFunction.body;
     const { args } = callToFunction;
     return [
       {
         code: this.expressionsCompiler.compileExpressions(code.execute, args),
-        revertCode: this.expressionsCompiler.compileExpressions(code.revert, args),
+        revertCode: (() => {
+          if (!code.revert) {
+            return undefined;
+          }
+          return this.expressionsCompiler.compileExpressions(code.revert, args);
+        })(),
       },
     ];
   }

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts

@@ -1,4 +1,4 @@
-import { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { CallFunctionBody, FunctionBodyType, ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
 import { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 import { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
@@ -13,7 +13,7 @@ export class NestedFunctionCallCompiler implements SingleCallCompilerStrategy {
   }
 
   public canCompile(func: ISharedFunction): boolean {
-    return func.body.calls !== undefined;
+    return func.body.type === FunctionBodyType.Calls;
   }
 
   public compileFunction(
@@ -21,7 +21,7 @@ export class NestedFunctionCallCompiler implements SingleCallCompilerStrategy {
     callToFunction: FunctionCall,
     context: FunctionCallCompilationContext,
   ): CompiledCode[] {
-    const nestedCalls = calledFunction.body.calls;
+    const nestedCalls = (calledFunction.body as CallFunctionBody).calls;
     return nestedCalls.map((nestedCall) => {
       try {
         const compiledParentCall = this.argumentCompiler

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

@@ -5,9 +5,6 @@ import { FunctionCallArgument } from './Argument/FunctionCallArgument';
 import { ParsedFunctionCall } from './ParsedFunctionCall';
 
 export function parseFunctionCalls(calls: FunctionCallsData): FunctionCall[] {
-  if (calls === undefined) {
-    throw new Error('missing call data');
-  }
   const sequence = getCallSequence(calls);
   return sequence.map((call) => parseFunctionCall(call));
 }
@@ -19,22 +16,21 @@ function getCallSequence(calls: FunctionCallsData): FunctionCallData[] {
   if (calls instanceof Array) {
     return calls as FunctionCallData[];
   }
-  return [calls as FunctionCallData];
+  const singleCall = calls;
+  return [singleCall];
 }
 
 function parseFunctionCall(call: FunctionCallData): FunctionCall {
-  if (!call) {
-    throw new Error('missing call data');
-  }
   const callArgs = parseArgs(call.parameters);
   return new ParsedFunctionCall(call.function, callArgs);
 }
 
 function parseArgs(
-  parameters: FunctionCallParametersData,
+  parameters: FunctionCallParametersData | undefined,
 ): FunctionCallArgumentCollection {
-  return Object.keys(parameters || {})
-    .map((parameterName) => new FunctionCallArgument(parameterName, parameters[parameterName]))
+  const parametersMap = parameters ?? {};
+  return Object.keys(parametersMap)
+    .map((parameterName) => new FunctionCallArgument(parameterName, parametersMap[parameterName]))
     .reduce((args, arg) => {
       args.addArgument(arg);
       return args;

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

@@ -9,8 +9,5 @@ export class ParsedFunctionCall implements FunctionCall {
     if (!functionName) {
       throw new Error('missing function name in function call');
     }
-    if (!args) {
-      throw new Error('missing args');
-    }
   }
 }

src/application/Parser/Script/Compiler/Function/ISharedFunction.ts

@@ -4,15 +4,21 @@ import { FunctionCall } from './Call/FunctionCall';
 export interface ISharedFunction {
   readonly name: string;
   readonly parameters: IReadOnlyFunctionParameterCollection;
-  readonly body: ISharedFunctionBody;
+  readonly body: SharedFunctionBody;
 }
 
-export interface ISharedFunctionBody {
-  readonly type: FunctionBodyType;
-  readonly code: IFunctionCode | undefined;
-  readonly calls: readonly FunctionCall[] | undefined;
+export interface CallFunctionBody {
+  readonly type: FunctionBodyType.Calls,
+  readonly calls: readonly FunctionCall[],
 }
 
+export interface CodeFunctionBody {
+  readonly type: FunctionBodyType.Code;
+  readonly code: IFunctionCode,
+}
+
+export type SharedFunctionBody = CallFunctionBody | CodeFunctionBody;
+
 export enum FunctionBodyType {
   Code,
   Calls,

src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts

@@ -18,9 +18,6 @@ export class FunctionParameterCollection implements IFunctionParameterCollection
   }
 
   private ensureValidParameter(parameter: IFunctionParameter) {
-    if (!parameter) {
-      throw new Error('missing parameter');
-    }
     if (this.includesName(parameter.name)) {
       throw new Error(`duplicate parameter name: "${parameter.name}"`);
     }

src/application/Parser/Script/Compiler/Function/SharedFunction.ts

@@ -1,7 +1,7 @@
 import { FunctionCall } from './Call/FunctionCall';
 
 import {
-  FunctionBodyType, IFunctionCode, ISharedFunction, ISharedFunctionBody,
+  FunctionBodyType, IFunctionCode, ISharedFunction, SharedFunctionBody,
 } from './ISharedFunction';
 import { IReadOnlyFunctionParameterCollection } from './Parameter/IFunctionParameterCollection';
 
@@ -10,7 +10,7 @@ export function createCallerFunction(
   parameters: IReadOnlyFunctionParameterCollection,
   callSequence: readonly FunctionCall[],
 ): ISharedFunction {
-  if (!callSequence || !callSequence.length) {
+  if (!callSequence.length) {
     throw new Error(`missing call sequence in function "${name}"`);
   }
   return new SharedFunction(name, parameters, callSequence, FunctionBodyType.Calls);
@@ -33,7 +33,7 @@ export function createFunctionWithInlineCode(
 }
 
 class SharedFunction implements ISharedFunction {
-  public readonly body: ISharedFunctionBody;
+  public readonly body: SharedFunctionBody;
 
   constructor(
     public readonly name: string,
@@ -42,11 +42,22 @@ class SharedFunction implements ISharedFunction {
     bodyType: FunctionBodyType,
   ) {
     if (!name) { throw new Error('missing function name'); }
-    if (!parameters) { throw new Error('missing parameters'); }
-    this.body = {
-      type: bodyType,
-      code: bodyType === FunctionBodyType.Code ? content as IFunctionCode : undefined,
-      calls: bodyType === FunctionBodyType.Calls ? content as readonly FunctionCall[] : undefined,
-    };
+
+    switch (bodyType) {
+      case FunctionBodyType.Code:
+        this.body = {
+          type: FunctionBodyType.Code,
+          code: content as IFunctionCode,
+        };
+        break;
+      case FunctionBodyType.Calls:
+        this.body = {
+          type: FunctionBodyType.Calls,
+          calls: content as readonly FunctionCall[],
+        };
+        break;
+      default:
+        throw new Error(`unknown body type: ${FunctionBodyType[bodyType]}`);
+    }
   }
 }

src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts

@@ -5,7 +5,6 @@ export class SharedFunctionCollection implements ISharedFunctionCollection {
   private readonly functionsByName = new Map<string, ISharedFunction>();
 
   public addFunction(func: ISharedFunction): void {
-    if (!func) { throw new Error('missing function'); }
     if (this.has(func.name)) {
       throw new Error(`function with name ${func.name} already exists`);
     }

src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts

@@ -1,4 +1,6 @@
-import type { FunctionData, InstructionHolder } from '@/application/collections/';
+import type {
+  FunctionData, CodeInstruction, CodeFunctionData, CallFunctionData, CallInstruction,
+} from '@/application/collections/';
 import { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
 import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
@@ -23,9 +25,8 @@ export class SharedFunctionsParser implements ISharedFunctionsParser {
     functions: readonly FunctionData[],
     syntax: ILanguageSyntax,
   ): ISharedFunctionCollection {
-    if (!syntax) { throw new Error('missing syntax'); }
     const collection = new SharedFunctionCollection();
-    if (!functions || !functions.length) {
+    if (!functions.length) {
       return collection;
     }
     ensureValidFunctions(functions);
@@ -55,16 +56,18 @@ function parseFunction(
 }
 
 function validateCode(
-  data: FunctionData,
+  data: CodeFunctionData,
   syntax: ILanguageSyntax,
   validator: ICodeValidator,
 ): void {
-  [data.code, data.revertCode].forEach(
-    (code) => validator.throwIfInvalid(
-      code,
-      [new NoEmptyLines(), new NoDuplicatedLines(syntax)],
-    ),
-  );
+  [data.code, data.revertCode]
+    .filter((code): code is string => Boolean(code))
+    .forEach(
+      (code) => validator.throwIfInvalid(
+        code,
+        [new NoEmptyLines(), new NoDuplicatedLines(syntax)],
+      ),
+    );
 }
 
 function parseParameters(data: FunctionData): IReadOnlyFunctionParameterCollection {
@@ -85,19 +88,18 @@ function parseParameters(data: FunctionData): IReadOnlyFunctionParameterCollecti
     }, new FunctionParameterCollection());
 }
 
-function hasCode(data: FunctionData): boolean {
-  return Boolean(data.code);
+function hasCode(data: FunctionData): data is CodeFunctionData {
+  return (data as CodeInstruction).code !== undefined;
 }
 
-function hasCall(data: FunctionData): boolean {
-  return Boolean(data.call);
+function hasCall(data: FunctionData): data is CallFunctionData {
+  return (data as CallInstruction).call !== undefined;
 }
 
 function ensureValidFunctions(functions: readonly FunctionData[]) {
-  ensureNoUndefinedItem(functions);
   ensureNoDuplicatesInFunctionNames(functions);
-  ensureNoDuplicateCode(functions);
   ensureEitherCallOrCodeIsDefined(functions);
+  ensureNoDuplicateCode(functions);
   ensureExpectedParametersType(functions);
 }
 
@@ -105,7 +107,7 @@ function printList(list: readonly string[]): string {
   return `"${list.join('","')}"`;
 }
 
-function ensureEitherCallOrCodeIsDefined(holders: readonly InstructionHolder[]) {
+function ensureEitherCallOrCodeIsDefined(holders: readonly FunctionData[]) {
   // Ensure functions do not define both call and code
   const withBothCallAndCode = holders.filter((holder) => hasCode(holder) && hasCall(holder));
   if (withBothCallAndCode.length) {
@@ -132,7 +134,7 @@ function isArrayOfObjects(value: unknown): boolean {
     && value.every((item) => typeof item === 'object');
 }
 
-function printNames(holders: readonly InstructionHolder[]) {
+function printNames(holders: readonly FunctionData[]) {
   return printList(holders.map((holder) => holder.name));
 }
 
@@ -144,22 +146,19 @@ function ensureNoDuplicatesInFunctionNames(functions: readonly FunctionData[]) {
   }
 }
 
-function ensureNoUndefinedItem(functions: readonly FunctionData[]) {
-  if (functions.some((func) => !func)) {
-    throw new Error('some functions are undefined');
-  }
-}
-
 function ensureNoDuplicateCode(functions: readonly FunctionData[]) {
-  const duplicateCodes = getDuplicates(functions
+  const callFunctions = functions
+    .filter((func) => hasCode(func))
+    .map((func) => func as CodeFunctionData);
+  const duplicateCodes = getDuplicates(callFunctions
     .map((func) => func.code)
     .filter((code) => code));
   if (duplicateCodes.length > 0) {
     throw new Error(`duplicate "code" in functions: ${printList(duplicateCodes)}`);
   }
-  const duplicateRevertCodes = getDuplicates(functions
-    .filter((func) => func.revertCode)
-    .map((func) => func.revertCode));
+  const duplicateRevertCodes = getDuplicates(callFunctions
+    .map((func) => func.revertCode)
+    .filter((code): code is string => Boolean(code)));
   if (duplicateRevertCodes.length > 0) {
     throw new Error(`duplicate "revertCode" in functions: ${printList(duplicateRevertCodes)}`);
   }

src/application/Parser/Script/Compiler/ScriptCompiler.ts

@@ -1,4 +1,4 @@
-import type { FunctionData, ScriptData } from '@/application/collections/';
+import type { FunctionData, ScriptData, CallInstruction } from '@/application/collections/';
 import { IScriptCode } from '@/domain/IScriptCode';
 import { ScriptCode } from '@/domain/ScriptCode';
 import { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
@@ -18,27 +18,24 @@ export class ScriptCompiler implements IScriptCompiler {
   private readonly functions: ISharedFunctionCollection;
 
   constructor(
-    functions: readonly FunctionData[] | undefined,
+    functions: readonly FunctionData[],
     syntax: ILanguageSyntax,
     sharedFunctionsParser: ISharedFunctionsParser = SharedFunctionsParser.instance,
     private readonly callCompiler: FunctionCallCompiler = FunctionCallSequenceCompiler.instance,
     private readonly codeValidator: ICodeValidator = CodeValidator.instance,
   ) {
-    if (!syntax) { throw new Error('missing syntax'); }
     this.functions = sharedFunctionsParser.parseFunctions(functions, syntax);
   }
 
   public canCompile(script: ScriptData): boolean {
-    if (!script) { throw new Error('missing script'); }
-    if (!script.call) {
-      return false;
-    }
-    return true;
+    return hasCall(script);
   }
 
   public compile(script: ScriptData): IScriptCode {
-    if (!script) { throw new Error('missing script'); }
     try {
+      if (!hasCall(script)) {
+        throw new Error('Script does include any calls.');
+      }
       const calls = parseFunctionCalls(script.call);
       const compiledCode = this.callCompiler.compileFunctionCalls(calls, this.functions);
       validateCompiledCode(compiledCode, this.codeValidator);
@@ -53,7 +50,17 @@ export class ScriptCompiler implements IScriptCompiler {
 }
 
 function validateCompiledCode(compiledCode: CompiledCode, validator: ICodeValidator): void {
-  [compiledCode.code, compiledCode.revertCode].forEach(
-    (code) => validator.throwIfInvalid(code, [new NoEmptyLines()]),
-  );
+  [compiledCode.code, compiledCode.revertCode]
+    .filter((code): code is string => Boolean(code))
+    .map((code) => code as string)
+    .forEach(
+      (code) => validator.throwIfInvalid(
+        code,
+        [new NoEmptyLines()],
+      ),
+    );
+}
+
+function hasCall(data: ScriptData): data is ScriptData & CallInstruction {
+  return (data as CallInstruction).call !== undefined;
 }

src/application/Parser/Script/ScriptParser.ts

@@ -1,4 +1,4 @@
-import type { ScriptData } from '@/application/collections/';
+import type { ScriptData, CodeScriptData, CallScriptData } from '@/application/collections/';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
 import { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
 import { Script } from '@/domain/Script';
@@ -14,7 +14,6 @@ import { ICategoryCollectionParseContext } from './ICategoryCollectionParseConte
 import { CodeValidator } from './Validation/CodeValidator';
 import { NoDuplicatedLines } from './Validation/Rules/NoDuplicatedLines';
 
-// eslint-disable-next-line consistent-return
 export function parseScript(
   data: ScriptData,
   context: ICategoryCollectionParseContext,
@@ -24,7 +23,6 @@ export function parseScript(
 ): Script {
   const validator = new NodeValidator({ type: NodeType.Script, selfNode: data });
   validateScript(data, validator);
-  if (!context) { throw new Error('missing context'); }
   try {
     const script = scriptFactory(
       /* name: */ data.name,
@@ -34,12 +32,12 @@ export function parseScript(
     );
     return script;
   } catch (err) {
-    validator.throw(err.message);
+    return validator.throw(err.message);
   }
 }
 
 function parseLevel(
-  level: string,
+  level: string | undefined,
   parser: IEnumParser<RecommendationLevel>,
 ): RecommendationLevel | undefined {
   if (!level) {
@@ -56,39 +54,45 @@ function parseCode(
   if (context.compiler.canCompile(script)) {
     return context.compiler.compile(script);
   }
-  const code = new ScriptCode(script.code, script.revertCode);
+  const codeScript = script as CodeScriptData; // Must be inline code if it cannot be compiled
+  const code = new ScriptCode(codeScript.code, codeScript.revertCode);
   validateHardcodedCodeWithoutCalls(code, codeValidator, context.syntax);
   return code;
 }
 
 function validateHardcodedCodeWithoutCalls(
   scriptCode: ScriptCode,
-  codeValidator: ICodeValidator,
+  validator: ICodeValidator,
   syntax: ILanguageSyntax,
 ) {
-  [scriptCode.execute, scriptCode.revert].forEach(
-    (code) => codeValidator.throwIfInvalid(
-      code,
-      [new NoEmptyLines(), new NoDuplicatedLines(syntax)],
-    ),
-  );
+  [scriptCode.execute, scriptCode.revert]
+    .filter((code): code is string => Boolean(code))
+    .forEach(
+      (code) => validator.throwIfInvalid(
+        code,
+        [new NoEmptyLines(), new NoDuplicatedLines(syntax)],
+      ),
+    );
 }
 
-function validateScript(script: ScriptData, validator: NodeValidator) {
+function validateScript(
+  script: ScriptData,
+  validator: NodeValidator,
+): asserts script is NonNullable<ScriptData> {
   validator
     .assertDefined(script)
     .assertValidName(script.name)
     .assert(
-      () => Boolean(script.code || script.call),
-      'Must define either "call" or "code".',
+      () => Boolean((script as CodeScriptData).code || (script as CallScriptData).call),
+      'Neither "call" or "code" is defined.',
     )
     .assert(
-      () => !(script.code && script.call),
-      'Cannot define both "call" and "code".',
+      () => !((script as CodeScriptData).code && (script as CallScriptData).call),
+      'Both "call" and "code" are defined.',
     )
     .assert(
-      () => !(script.revertCode && script.call),
-      'Cannot define "revertCode" if "call" is defined.',
+      () => !((script as CodeScriptData).revertCode && (script as CallScriptData).call),
+      'Both "call" and "revertCode" are defined.',
     );
 }
 

src/application/Parser/Script/Validation/CodeValidator.ts

@@ -9,7 +9,7 @@ export class CodeValidator implements ICodeValidator {
     code: string,
     rules: readonly ICodeValidationRule[],
   ): void {
-    if (!rules || rules.length === 0) { throw new Error('missing rules'); }
+    if (rules.length === 0) { throw new Error('missing rules'); }
     if (!code) {
       return;
     }

src/application/Parser/Script/Validation/Rules/NoDuplicatedLines.ts

@@ -3,9 +3,7 @@ import { ICodeLine } from '../ICodeLine';
 import { ICodeValidationRule, IInvalidCodeLine } from '../ICodeValidationRule';
 
 export class NoDuplicatedLines implements ICodeValidationRule {
-  constructor(private readonly syntax: ILanguageSyntax) {
-    if (!syntax) { throw new Error('missing syntax'); }
-  }
+  constructor(private readonly syntax: ILanguageSyntax) { }
 
   public analyze(lines: readonly ICodeLine[]): IInvalidCodeLine[] {
     return lines