Pass the value to stop after rather than calling each time

jakebailey · jakebailey · commit 42d68cbae59c · 2023-08-01T14:38:06.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -21303,13 +21303,12 @@ 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.
-                        maybeKeys.popAll(v => {
+                        maybeKeys.popUntilInclusive(id, v => {
                             relation.set(v, RelationComparisonResult.Succeeded | propagatingVarianceFlags);
-                            return v === id;
                         });
                     }
                     else {
-                        maybeKeys.popAll(v => v === id);
+                        maybeKeys.popUntilInclusive(id);
                     }
                 }
                 // Note: it's intentional that we don't pop in the else case;
@@ -21320,7 +21319,7 @@ 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);
-                maybeKeys.popAll(v => v === id);
+                maybeKeys.popUntilInclusive(id);
             }
             return result;
         }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -2885,7 +2885,7 @@ export function isNodeLikeSystem(): boolean {
 
 
 /** @internal */
-export interface StackSet<T extends {}> {
+export interface StackSet<T> {
     /**
      * Returns true if the value has already been pushed.
      */
@@ -2895,17 +2895,16 @@ export interface StackSet<T extends {}> {
      */
     push(value: T): void;
     /**
-     * This pops from the stack until the callback returns true.
+     * This pops from the stack, stopping iteration after v is found.
      *
-     * Note that a value is popped, _then_ the callback is evaluated, meaning
-     * that if you return true to stop iteration, the value that the callback
-     * returned true for will still have been popped.
+     * Note that the callback is evaluated _after_ the item is popped, meaning
+     * the callback will execute for v and it will not remain on the stack.
      */
-    popAll(callback: (v: T) => boolean): void;
+    popUntilInclusive(v: T, callback?: (v: T) => void): void;
 }
 
 /** @internal */
-export function createStackSet<T extends {}>(): StackSet<T> {
+export function createStackSet<T>(): StackSet<T> {
     // 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 */
@@ -2924,13 +2923,14 @@ export function createStackSet<T extends {}>(): StackSet<T> {
             stack[end] = value;
             end++;
         },
-        popAll(callback) {
+        popUntilInclusive(v, callback) {
             while (end > 0) {
                 end--;
                 const value = stack[end];
                 set.delete(value);
-                if (callback(value)) {
-                    break;
+                callback?.(value);
+                if (value === v) {
+                    return;
                 }
             }
         },

Original file line number	Diff line number	Diff line change
`@@ -21303,13 +21303,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`21303`	`21303`	`if (result === Ternary.True \|\| result === Ternary.Maybe) {`
`21304`	`21304`	`// If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe`
`21305`	`21305`	`// results as having succeeded once we reach depth 0, but never record Ternary.Unknown results.`
`21306`		`- maybeKeys.popAll(v => {`
	`21306`	`+ maybeKeys.popUntilInclusive(id, v => {`
`21307`	`21307`	`relation.set(v, RelationComparisonResult.Succeeded \| propagatingVarianceFlags);`
`21308`		`- return v === id;`
`21309`	`21308`	`});`
`21310`	`21309`	`}`
`21311`	`21310`	`else {`
`21312`		`- maybeKeys.popAll(v => v === id);`
	`21311`	`+ maybeKeys.popUntilInclusive(id);`
`21313`	`21312`	`}`
`21314`	`21313`	`}`
`21315`	`21314`	`// Note: it's intentional that we don't pop in the else case;`
`@@ -21320,7 +21319,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`21320`	`21319`	`// A false result goes straight into global cache (when something is false under`
`21321`	`21320`	`// assumptions it will also be false without assumptions)`
`21322`	`21321`	`relation.set(id, (reportErrors ? RelationComparisonResult.Reported : 0) \| RelationComparisonResult.Failed \| propagatingVarianceFlags);`
`21323`		`- maybeKeys.popAll(v => v === id);`
	`21322`	`+ maybeKeys.popUntilInclusive(id);`
`21324`	`21323`	`}`
`21325`	`21324`	`return result;`
`21326`	`21325`	`}`