Prove the values the non-null assertions asserted, where a test or loop form can

src/noldova.context.testing/src/resources.ts

@@ -96,7 +96,9 @@ export class Resources {
   public static readonly terminalYellow: string = "\u001b[33m";
   public static readonly terminalReset: string = "\u001b[0m";
   public static readonly terminalClearLine: string = "\r\u001b[2K";
-  public static readonly progressFrames: readonly string[] = ["Running tests.", "Running tests..", "Running tests..."];
+  public static readonly progressText: string = "Running tests";
+  public static readonly progressDot: string = ".";
+  public static readonly progressMaximumDots: number = 3;
   public static readonly progressIntervalMilliseconds: number = 300;
   public static readonly centisecondsPerSecond: number = 100;
   public static readonly durationDecimalPlaces: number = 2;

src/noldova.context.testing/src/services/reporting/test-console-reporter.ts

@@ -76,13 +76,13 @@ export class TestConsoleReporter implements ITestProgressListener {
   }
 
   private advanceProgress(): void {
-    this.progressFrame = (this.progressFrame + 1) % Resources.progressFrames.length;
+    this.progressFrame = (this.progressFrame + 1) % Resources.progressMaximumDots;
     this.drawProgress();
     this.scheduleProgress();
   }
 
   private drawProgress(): void {
-    this.write(`${Resources.terminalClearLine}${Resources.progressFrames[this.progressFrame]!}`);
+    this.write(`${Resources.terminalClearLine}${Resources.progressText}${Resources.progressDot.repeat(this.progressFrame + 1)}`);
   }
 
   private writeLines(lines: readonly string[]): void {

src/parsers/noldova.context.parsers.regex/tests/conformance/conformance-cases.test.ts

@@ -24,7 +24,9 @@ export class ConformanceCasesTests {
 
   @TestMethod
   public matchesTest262UnlessKnownToFail(casePath: string): void {
-    const verdict = ConformanceCaseVerdict.of(ConformanceExpectationsReader.load().applicableRecords.get(casePath)!);
+    const record = ConformanceExpectationsReader.load().applicableRecords.get(casePath);
+    Assert.isDefined(record, casePath);
+    const verdict = ConformanceCaseVerdict.of(record);
 
     const failure = KnownFailuresLedger.load().failing.get(casePath);
     if (Object.isUndefined(failure))

src/parsers/noldova.context.parsers.typescript/src/api/index.d.ts

@@ -9023,7 +9023,8 @@ export declare class TypeScriptTypeLiteralNode extends CompositeNode {
  * const operand = new TypeScriptIdentifierNode("Value", new SourceSpan(1, 5));
  * const operator = new TypeScriptQuestionNode(new SourceSpan(0, 1));
  * const type = new TypeScriptTypeOperatorNode(operator, new SourceSpan(0, 6), operand);
- * type.operatorNode.span.startOffset < type.typeNode!.span.startOffset; // prefix
+ * type.typeNode === operand; // true
+ * type.operatorNode.span.startOffset < operand.span.startOffset; // prefix
  * ```
  */
 export declare class TypeScriptTypeOperatorNode extends Node {

src/parsers/noldova.context.parsers.typescript/src/extensions/nodes/declarations/typescript-binding-element.node.extensions.ts

@@ -36,8 +36,8 @@ TypeScriptBindingElementNode.prototype.hasTypeScriptBindingName = function (this
 };
 
 TypeScriptBindingElementNode.prototype.reportTypeScriptRestInitializer = function (this: TypeScriptBindingElementNode, context: TypeScriptParserContext): void {
-  if (!Object.isUndefined(this.dotDotDotNode) && Object.isUndefined(this.propertyNameNode) && !Object.isUndefined(this.initializerNode))
-    context.diagnosticCollector.addTypeScriptGrammarDiagnostic(context.source, TypeScriptDiagnosticTemplates.TS1186, this.equalsNode!.span);
+  if (!Object.isUndefined(this.dotDotDotNode) && Object.isUndefined(this.propertyNameNode) && !Object.isUndefined(this.equalsNode))
+    context.diagnosticCollector.addTypeScriptGrammarDiagnostic(context.source, TypeScriptDiagnosticTemplates.TS1186, this.equalsNode.span);
 };
 
 TypeScriptBindingElementNode.prototype.isTypeScriptRestElement = function (this: TypeScriptBindingElementNode): boolean {

src/parsers/noldova.context.parsers.typescript/src/extensions/nodes/statements/typescript-for-in-or-of-statement.node.extensions.ts

@@ -42,7 +42,8 @@ TypeScriptForInOrOfStatementNode.prototype.validateTypeScriptGrammar = function
     return;
 
   const isUsing = initializerNode.keywordNode instanceof TypeScriptUsingKeywordNode;
-  if (initializerNode.children.length === 0 || !Object.isUndefined(initializerNode.getTypeScriptTrailingComma()))
+  const [declarationNode, secondDeclarationNode] = initializerNode.children;
+  if (Object.isUndefined(declarationNode) || !Object.isUndefined(initializerNode.getTypeScriptTrailingComma()))
     return;
   if (isUsing && !isForOf) {
     const template = Object.isUndefined(initializerNode.awaitKeywordNode)
@@ -58,15 +59,13 @@ TypeScriptForInOrOfStatementNode.prototype.validateTypeScriptGrammar = function
   if (!Object.isUndefined(initializerNode.awaitKeywordNode) && (context.isClassStaticBlock || !context.isAwaitContext))
     return;
 
-  const secondDeclarationNode = initializerNode.children[1];
   if (!Object.isUndefined(secondDeclarationNode)) {
     context.diagnosticCollector.addTypeScriptGrammarDiagnostic(context.source,
       isForOf ? TypeScriptDiagnosticTemplates.TS1188 : TypeScriptDiagnosticTemplates.TS1091,
       secondDeclarationNode.nameNode.getTypeScriptFirstTokenSpan());
     return;
   }
 
-  const declarationNode = initializerNode.children[0]!;
   if (!Object.isUndefined(declarationNode.initializerNode))
     context.diagnosticCollector.addTypeScriptGrammarDiagnostic(context.source,
       isForOf ? TypeScriptDiagnosticTemplates.TS1190 : TypeScriptDiagnosticTemplates.TS1189, declarationNode.nameNode.span);

src/parsers/noldova.context.parsers.typescript/tests/conformance/conformance-cases.test.ts

@@ -28,7 +28,8 @@ export class ConformanceCasesTests {
   @TestMethod
   public matchesTheReferenceUnlessKnownToFail(casePath: string): void {
     const expectations = ConformanceExpectationsReader.load();
-    const record = expectations.applicableRecords.get(casePath)!;
+    const record = expectations.applicableRecords.get(casePath);
+    Assert.isDefined(record, casePath);
     const verdict = new ConformanceCaseComparison(record, expectations.readUnits(record), ParserDiagnosticScope.load()).run();
 
     const failure = KnownFailuresLedger.load().failing.get(casePath);

src/parsers/noldova.context.parsers.typescript/tests/fixtures/typescript-diagnostics.fixture.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { Diagnostic } from "@noldova/context.diagnostics";
+import type { Diagnostic, DiagnosticRelatedInformation } from "@noldova/context.diagnostics";
 import { TypeScriptParser } from "@noldova/context.parsers.typescript";
 import { Assert } from "@noldova/context.testing";
 
@@ -33,7 +33,7 @@ export class TypeScriptDiagnosticsFixture {
 
   public static projectWithRelated(diagnostics: readonly Diagnostic[]): string {
     return diagnostics.map(t => TypeScriptDiagnosticsFixture.position(t)
-      + t.relatedInformation.map(related => `{${related.message.text}@${related.location!.start}}`).join(String.empty))
+      + t.relatedInformation.map(related => TypeScriptDiagnosticsFixture.related(related)).join(String.empty))
       .join(TypeScriptDiagnosticsFixture.SEPARATOR);
   }
 
@@ -52,4 +52,10 @@ export class TypeScriptDiagnosticsFixture {
     Assert.isDefined(location);
     return content.slice(location.start, location.start + location.length);
   }
+
+  private static related(related: DiagnosticRelatedInformation): string {
+    const location = related.location;
+    Assert.isDefined(location);
+    return `{${related.message.text}@${location.start}}`;
+  }
 }