fix(data-structures/unstable): BidirectionalMap differentiate extant undefined from missing values (#6606)

Author: lionel-rowe

data_structures/unstable_bidirectional_map.ts

@@ -95,13 +95,11 @@ export class BidirectionalMap<K, V> extends Map<K, V> {
    * ```
    */
   override set(key: K, value: V): this {
-    const oldValue = super.get(key);
-    if (oldValue !== undefined) {
-      this.#reverseMap.delete(oldValue);
+    if (super.has(key)) {
+      this.#reverseMap.delete(super.get(key)!);
     }
-    const oldKey = this.#reverseMap.get(value);
-    if (oldKey !== undefined) {
-      super.delete(oldKey);
+    if (this.#reverseMap.has(value)) {
+      super.delete(this.#reverseMap.get(value)!);
     }
     super.set(key, value);
     this.#reverseMap.set(value, key);
@@ -151,8 +149,8 @@ export class BidirectionalMap<K, V> extends Map<K, V> {
    * ```
    */
   override delete(key: K): boolean {
-    const value = super.get(key);
-    if (value === undefined) return false;
+    if (!super.has(key)) return false;
+    const value = super.get(key)!;
     return super.delete(key) && this.#reverseMap.delete(value);
   }
 
@@ -179,8 +177,8 @@ export class BidirectionalMap<K, V> extends Map<K, V> {
    * ```
    */
   deleteReverse(value: V): boolean {
-    const key = this.#reverseMap.get(value);
-    if (key === undefined) return false;
+    if (!this.#reverseMap.has(value)) return false;
+    const key = this.#reverseMap.get(value)!;
     return super.delete(key) && this.#reverseMap.delete(value);
   }
 

data_structures/unstable_bidirectional_map_test.ts

@@ -323,3 +323,62 @@ Deno.test(
     assertEquals(bidiFromArr, bidiFromIter);
   },
 );
+
+Deno.test(
+  "BidirectionalMap differentiates extant `undefined` from missing values, consistently with `Map`",
+  async (t) => {
+    let bidi: BidirectionalMap<number | undefined, number | undefined>;
+
+    await t.step("delete", () => {
+      bidi = new BidirectionalMap([[0, undefined]]);
+      assertEquals(bidi.delete(0), true);
+      assertEquals(bidi.delete(0), false);
+      assertEquals(bidi.delete(1), false);
+    });
+
+    await t.step("deleteReverse", () => {
+      bidi = new BidirectionalMap([[undefined, 0]]);
+      assertEquals(bidi.deleteReverse(0), true);
+      assertEquals(bidi.deleteReverse(0), false);
+      assertEquals(bidi.deleteReverse(1), false);
+    });
+
+    await t.step("has", () => {
+      bidi = new BidirectionalMap([[undefined, undefined]]);
+      assertEquals(bidi.has(undefined), true);
+      bidi.set(1, undefined);
+      // gets removed due to `undefined` value (reverse key) being overwritten
+      assertEquals(bidi.has(undefined), false);
+    });
+
+    await t.step("hasReverse", () => {
+      bidi = new BidirectionalMap([[undefined, undefined]]);
+      assertEquals(bidi.hasReverse(undefined), true);
+      bidi.set(undefined, 1);
+      // gets removed due to `undefined` key being overwritten
+      assertEquals(bidi.hasReverse(undefined), false);
+    });
+
+    await t.step("set", () => {
+      bidi = new BidirectionalMap([[undefined, undefined]]);
+      bidi.set(undefined, 1);
+      assertEquals([...bidi], [[undefined, 1]]);
+
+      bidi = new BidirectionalMap([[undefined, undefined]]);
+      bidi.set(1, undefined);
+      assertEquals([...bidi], [[1, undefined]]);
+
+      bidi = new BidirectionalMap([]);
+      bidi.set(undefined, undefined);
+      assertEquals([...bidi], [[undefined, undefined]]);
+
+      bidi = new BidirectionalMap([]);
+      bidi.set(undefined, 1);
+      assertEquals([...bidi], [[undefined, 1]]);
+
+      bidi = new BidirectionalMap([]);
+      bidi.set(1, undefined);
+      assertEquals([...bidi], [[1, undefined]]);
+    });
+  },
+);