fix Set iterator not reflecting mutations after creation (#1671)

RealColdFry · RealColdFry · commit a7c06f1ff6d9 · 2026-03-17T19:06:52.000Z
Set.values(), keys(), and entries() eagerly captured firstKey at
iterator creation time. If the Set was mutated (e.g. via delete)
before the iterator was consumed, the iterator still saw the stale
firstKey. Read firstKey lazily on the first next() call instead.
diff --git a/src/lualib/Set.ts b/src/lualib/Set.ts
@@ -102,46 +102,64 @@ export class Set<T extends AnyNotNil> {
     }
 
     public entries(): IterableIterator<[T, T]> {
+        const getFirstKey = () => this.firstKey;
         const nextKey = this.nextKey;
-        let key: T = this.firstKey!;
+        let key: T | undefined;
+        let started = false;
         return {
             [Symbol.iterator](): IterableIterator<[T, T]> {
                 return this;
             },
             next(): IteratorResult<[T, T]> {
-                const result = { done: !key, value: [key, key] as [T, T] };
-                key = nextKey.get(key);
-                return result;
+                if (!started) {
+                    started = true;
+                    key = getFirstKey();
+                } else {
+                    key = nextKey.get(key!);
+                }
+                return { done: !key, value: [key!, key!] as [T, T] };
             },
         };
     }
 
     public keys(): IterableIterator<T> {
+        const getFirstKey = () => this.firstKey;
         const nextKey = this.nextKey;
-        let key: T = this.firstKey!;
+        let key: T | undefined;
+        let started = false;
         return {
             [Symbol.iterator](): IterableIterator<T> {
                 return this;
             },
             next(): IteratorResult<T> {
-                const result = { done: !key, value: key };
-                key = nextKey.get(key);
-                return result;
+                if (!started) {
+                    started = true;
+                    key = getFirstKey();
+                } else {
+                    key = nextKey.get(key!);
+                }
+                return { done: !key, value: key! };
             },
         };
     }
 
     public values(): IterableIterator<T> {
+        const getFirstKey = () => this.firstKey;
         const nextKey = this.nextKey;
-        let key: T = this.firstKey!;
+        let key: T | undefined;
+        let started = false;
         return {
             [Symbol.iterator](): IterableIterator<T> {
                 return this;
             },
             next(): IteratorResult<T> {
-                const result = { done: !key, value: key };
-                key = nextKey.get(key);
-                return result;
+                if (!started) {
+                    started = true;
+                    key = getFirstKey();
+                } else {
+                    key = nextKey.get(key!);
+                }
+                return { done: !key, value: key! };
             },
         };
     }
diff --git a/test/unit/builtins/set.spec.ts b/test/unit/builtins/set.spec.ts
@@ -195,6 +195,19 @@ describe.each(iterationMethods)("set.%s() preserves insertion order", iterationM
     });
 });
 
+test("set iterator persists after delete", () => {
+    util.testFunction`
+        const set1 = new Set<string | number>();
+        set1.add(42);
+        set1.add("forty two");
+
+        const iterator1 = set1.values();
+        set1.delete(42);
+
+        return iterator1.next().value;
+    `.expectToMatchJsResult();
+});
+
 test("instanceof Set without creating set", () => {
     util.testFunction`
         const myset = 3 as any;
