skip Debug in core/scanner

Author: a-tarasyuk

src/compiler/core.ts

@@ -1,5 +1,5 @@
 import { Comparer, Comparison, EqualityComparer, MapLike, Push, SortedArray, SortedReadonlyArray } from "./corePublic";
-import { Debug } from "./debug";
+// import { Debug } from "./debug";
 import { __String, CharacterCodes, Queue, TextSpan, UnderscoreEscapedMap } from "./types";
 
 /** @internal */
@@ -122,7 +122,7 @@ export function reduceLeftIterator<T, U>(iterator: Iterator<T> | undefined, f: (
 /** @internal */
 export function zipWith<T, U, V>(arrayA: readonly T[], arrayB: readonly U[], callback: (a: T, b: U, index: number) => V): V[] {
     const result: V[] = [];
-    Debug.assertEqual(arrayA.length, arrayB.length);
+    // Debug.assertEqual(arrayA.length, arrayB.length);
     for (let i = 0; i < arrayA.length; i++) {
         result.push(callback(arrayA[i], arrayB[i], i));
     }
@@ -131,7 +131,7 @@ export function zipWith<T, U, V>(arrayA: readonly T[], arrayB: readonly U[], cal
 
 /** @internal */
 export function zipToIterator<T, U>(arrayA: readonly T[], arrayB: readonly U[]): Iterator<[T, U]> {
-    Debug.assertEqual(arrayA.length, arrayB.length);
+    // Debug.assertEqual(arrayA.length, arrayB.length);
     let i = 0;
     return {
         next() {
@@ -146,7 +146,7 @@ export function zipToIterator<T, U>(arrayA: readonly T[], arrayB: readonly U[]):
 
 /** @internal */
 export function zipToMap<K, V>(keys: readonly K[], values: readonly V[]): Map<K, V> {
-    Debug.assert(keys.length === values.length);
+    // Debug.assert(keys.length === values.length);
     const map = new Map<K, V>();
     for (let i = 0; i < keys.length; ++i) {
         map.set(keys[i], values[i]);
@@ -266,7 +266,8 @@ export function findMap<T, U>(array: readonly T[], callback: (element: T, index:
             return result;
         }
     }
-    return Debug.fail();
+    // return Debug.fail();
+    throw new Error();
 }
 
 /** @internal */
@@ -884,7 +885,8 @@ function deduplicateSorted<T>(array: SortedReadonlyArray<T>, comparer: EqualityC
 
             case Comparison.LessThan:
                 // If `array` is sorted, `next` should **never** be less than `last`.
-                return Debug.fail("Array is unsorted.");
+                // return Debug.fail("Array is unsorted.");
+                throw new Error("Array is unsorted.");
         }
 
         deduplicated.push(last = next);
@@ -1005,14 +1007,14 @@ export function relativeComplement<T>(arrayA: T[] | undefined, arrayB: T[] | und
     loopB: for (let offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
         if (offsetB > 0) {
             // Ensure `arrayB` is properly sorted.
-            Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), Comparison.EqualTo);
+            // Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), Comparison.EqualTo);
         }
 
         loopA: for (const startA = offsetA; offsetA < arrayA.length; offsetA++) {
             if (offsetA > startA) {
                 // Ensure `arrayA` is properly sorted. We only need to perform this check if
                 // `offsetA` has changed since we entered the loop.
-                Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), Comparison.EqualTo);
+                // Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), Comparison.EqualTo);
             }
 
             switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
@@ -1259,7 +1261,7 @@ export function firstOrUndefined<T>(array: readonly T[] | undefined): T | undefi
 
 /** @internal */
 export function first<T>(array: readonly T[]): T {
-    Debug.assert(array.length !== 0);
+    // Debug.assert(array.length !== 0);
     return array[0];
 }
 
@@ -1274,7 +1276,7 @@ export function lastOrUndefined<T>(array: readonly T[] | undefined): T | undefin
 
 /** @internal */
 export function last<T>(array: readonly T[]): T {
-    Debug.assert(array.length !== 0);
+    // Debug.assert(array.length !== 0);
     return array[array.length - 1];
 }
 
@@ -1295,7 +1297,12 @@ export function singleOrUndefined<T>(array: readonly T[] | undefined): T | undef
  * @internal
  */
 export function single<T>(array: readonly T[]): T {
-    return Debug.checkDefined(singleOrUndefined(array));
+    // return Debug.checkDefined(singleOrUndefined(array));
+    const result = singleOrUndefined(array);
+    if (result === undefined) {
+        throw new Error();
+    }
+    return result;
 }
 
 /**
@@ -1991,8 +1998,8 @@ export function tryCast<T>(value: T, test: (value: T) => boolean): T | undefined
 /** @internal */
 export function cast<TOut extends TIn, TIn = any>(value: TIn | undefined, test: (value: TIn) => value is TOut): TOut {
     if (value !== undefined && test(value)) return value;
-
-    return Debug.fail(`Invalid cast. The supplied value ${value} did not pass the test '${Debug.getFunctionName(test)}'.`);
+    throw new Error(`Invalid cast. The supplied value ${value} did not pass the test`);
+    // return Debug.fail(`Invalid cast. The supplied value ${value} did not pass the test '${Debug.getFunctionName(test)}'.`);
 }
 
 /**
@@ -2478,7 +2485,7 @@ export function getSpellingSuggestion<T>(name: string, candidates: T[], getName:
                 continue;
             }
 
-            Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined
+            // Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined
             bestDistance = distance;
             bestCandidate = candidate;
         }
@@ -2692,7 +2699,7 @@ export function patternText({ prefix, suffix }: Pattern): string {
  * @internal
  */
 export function matchedText(pattern: Pattern, candidate: string): string {
-    Debug.assert(isPatternMatch(pattern, candidate));
+    // Debug.assert(isPatternMatch(pattern, candidate));
     return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
 }