Maybe improve perf

jakebailey · jakebailey · commit a703f482a86e · 2023-08-01T11:22:55.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -21248,7 +21248,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     return Ternary.False;
                 }
             }
-            const maybeStart = maybeKeys.size;
+            // const maybeStart = maybeKeys.size;
             maybeKeys.push(id);
             const saveExpandingFlags = expandingFlags;
             if (recursionFlags & RecursionFlags.Source) {
@@ -21304,14 +21304,20 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (result === Ternary.True || result === Ternary.Maybe) {
                         // If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe
                         // results as having succeeded once we reach depth 0, but never record Ternary.Unknown results.
-                        while (maybeKeys.size > maybeStart) {
-                            const id = maybeKeys.pop();
-                            relation.set(id, RelationComparisonResult.Succeeded | propagatingVarianceFlags);
+                        while (true) {
+                            const popped = maybeKeys.pop();
+                            relation.set(popped, RelationComparisonResult.Succeeded | propagatingVarianceFlags);
+                            if (popped === id) {
+                                break;
+                            }
                         }
                     }
                     else {
-                        while (maybeKeys.size > maybeStart) {
-                            maybeKeys.pop();
+                        while (true) {
+                            const popped = maybeKeys.pop();
+                            if (popped === id) {
+                                break;
+                            }
                         }
                     }
                 }
@@ -21323,8 +21329,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // A false result goes straight into global cache (when something is false under
                 // assumptions it will also be false without assumptions)
                 relation.set(id, (reportErrors ? RelationComparisonResult.Reported : 0) | RelationComparisonResult.Failed | propagatingVarianceFlags);
-                while (maybeKeys.size > maybeStart) {
-                    maybeKeys.pop();
+                while (true) {
+                    const popped = maybeKeys.pop();
+                    if (popped === id) {
+                        break;
+                    }
                 }
             }
             return result;
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -2889,38 +2889,38 @@ export interface StackSet<T extends {}> {
     has(value: T): boolean;
     push(value: T): void;
     pop(): T;
-    get size(): number;
+    // get size(): number;
 }
 
 /** @internal */
 export function createStackSet<T extends {}>(): StackSet<T> {
-    const refs = new Map<T, number>();
-    const stack: T[] = [];
-    let end = 0;
+    // Why var? It avoids TDZ checks in the runtime which can be costly.
+    // See: https://github.com/microsoft/TypeScript/issues/52924
+    /* eslint-disable no-var */
+    var set = new Set<T>();
+    var stack: T[] = [];
+    var end = 0;
+    /* eslint-enable no-var */
+
     return {
         has(value) {
-            return refs.has(value);
+            return set.has(value);
         },
         push(value) {
-            refs.set(value, (refs.get(value) ?? 0) + 1);
+            // Debug.assert(!set.has(value), "Value already pushed");
+            set.add(value);
             stack[end] = value;
             end++;
         },
         pop() {
             end--;
-            Debug.assertGreaterThanOrEqual(end, 0);
+            // Debug.assertGreaterThanOrEqual(end, 0);
             const value = stack[end];
-            const refCount = refs.get(value)! - 1;
-            if (refCount === 0) {
-                refs.delete(value);
-            }
-            else {
-                refs.set(value, refCount);
-            }
+            set.delete(value);
             return value;
         },
-        get size() {
-            return end;
-        },
+        // get size() {
+        //     return end;
+        // },
     };
 }

Original file line number	Diff line number	Diff line change
`@@ -21248,7 +21248,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`21248`	`21248`	`return Ternary.False;`
`21249`	`21249`	`}`
`21250`	`21250`	`}`
`21251`		`- const maybeStart = maybeKeys.size;`
	`21251`	`+ // const maybeStart = maybeKeys.size;`
`21252`	`21252`	`maybeKeys.push(id);`
`21253`	`21253`	`const saveExpandingFlags = expandingFlags;`
`21254`	`21254`	`if (recursionFlags & RecursionFlags.Source) {`
`@@ -21304,14 +21304,20 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`21304`	`21304`	`if (result === Ternary.True \|\| result === Ternary.Maybe) {`
`21305`	`21305`	`// If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe`
`21306`	`21306`	`// results as having succeeded once we reach depth 0, but never record Ternary.Unknown results.`
`21307`		`- while (maybeKeys.size > maybeStart) {`
`21308`		`- const id = maybeKeys.pop();`
`21309`		`- relation.set(id, RelationComparisonResult.Succeeded \| propagatingVarianceFlags);`
	`21307`	`+ while (true) {`
	`21308`	`+ const popped = maybeKeys.pop();`
	`21309`	`+ relation.set(popped, RelationComparisonResult.Succeeded \| propagatingVarianceFlags);`
	`21310`	`+ if (popped === id) {`
	`21311`	`+ break;`
	`21312`	`+ }`
`21310`	`21313`	`}`
`21311`	`21314`	`}`
`21312`	`21315`	`else {`
`21313`		`- while (maybeKeys.size > maybeStart) {`
`21314`		`- maybeKeys.pop();`
	`21316`	`+ while (true) {`
	`21317`	`+ const popped = maybeKeys.pop();`
	`21318`	`+ if (popped === id) {`
	`21319`	`+ break;`
	`21320`	`+ }`
`21315`	`21321`	`}`
`21316`	`21322`	`}`
`21317`	`21323`	`}`
`@@ -21323,8 +21329,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`21323`	`21329`	`// A false result goes straight into global cache (when something is false under`
`21324`	`21330`	`// assumptions it will also be false without assumptions)`
`21325`	`21331`	`relation.set(id, (reportErrors ? RelationComparisonResult.Reported : 0) \| RelationComparisonResult.Failed \| propagatingVarianceFlags);`
`21326`		`- while (maybeKeys.size > maybeStart) {`
`21327`		`- maybeKeys.pop();`
	`21332`	`+ while (true) {`
	`21333`	`+ const popped = maybeKeys.pop();`
	`21334`	`+ if (popped === id) {`
	`21335`	`+ break;`
	`21336`	`+ }`
`21328`	`21337`	`}`
`21329`	`21338`	`}`
`21330`	`21339`	`return result;`