le/symbols as weak map keys

src/compiler/commandLineParser.ts

@@ -211,7 +211,11 @@ const libEntries: [string, string][] = [
     ["es2022.string", "lib.es2022.string.d.ts"],
     ["es2022.regexp", "lib.es2022.regexp.d.ts"],
     ["es2023.array", "lib.es2023.array.d.ts"],
+    ["es2023.collection", "lib.es2023.collection.d.ts"],
+    ["es2023.weakref", "lib.es2023.weakref.d.ts"],
     ["esnext.array", "lib.es2023.array.d.ts"],
+    ["esnext.collection", "lib.es2023.collection.d.ts"],
+    ["esnext.weakref", "lib.es2023.weakref.d.ts"],
     ["esnext.symbol", "lib.es2019.symbol.d.ts"],
     ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
     ["esnext.intl", "lib.esnext.intl.d.ts"],

src/lib/es2015.collection.d.ts

@@ -42,7 +42,13 @@ interface ReadonlyMap<K, V> {
     readonly size: number;
 }
 
-interface WeakMap<K extends object, V> {
+interface WeakKeyTypes {
+    object: object;
+}
+
+type WeakKey = WeakKeyTypes[keyof WeakKeyTypes];
+
+interface WeakMap<K extends WeakKey, V> {
     /**
      * Removes the specified element from the WeakMap.
      * @returns true if the element was successfully removed, or false if it was not present.
@@ -107,7 +113,7 @@ interface ReadonlySet<T> {
     readonly size: number;
 }
 
-interface WeakSet<T extends object> {
+interface WeakSet<T extends WeakKey> {
     /**
      * Appends a new object to the end of the WeakSet.
      */
@@ -124,7 +130,7 @@ interface WeakSet<T extends object> {
 }
 
 interface WeakSetConstructor {
-    new <T extends object = object>(values?: readonly T[] | null): WeakSet<T>;
-    readonly prototype: WeakSet<object>;
+    new <T extends WeakKey = WeakKey>(values?: readonly T[] | null): WeakSet<T>;
+    readonly prototype: WeakSet<WeakKey>;
 }
 declare var WeakSet: WeakSetConstructor;

src/lib/es2015.iterable.d.ts

@@ -141,10 +141,10 @@ interface MapConstructor {
     new <K, V>(iterable?: Iterable<readonly [K, V]> | null): Map<K, V>;
 }
 
-interface WeakMap<K extends object, V> { }
+interface WeakMap<K extends WeakKey, V> { }
 
 interface WeakMapConstructor {
-    new <K extends object, V>(iterable: Iterable<readonly [K, V]>): WeakMap<K, V>;
+    new <K extends WeakKey, V>(iterable: Iterable<readonly [K, V]>): WeakMap<K, V>;
 }
 
 interface Set<T> {
@@ -189,10 +189,10 @@ interface SetConstructor {
     new <T>(iterable?: Iterable<T> | null): Set<T>;
 }
 
-interface WeakSet<T extends object> { }
+interface WeakSet<T extends WeakKey> { }
 
 interface WeakSetConstructor {
-    new <T extends object = object>(iterable: Iterable<T>): WeakSet<T>;
+    new <T extends WeakKey = WeakKey>(iterable: Iterable<T>): WeakSet<T>;
 }
 
 interface Promise<T> { }

src/lib/es2015.symbol.wellknown.d.ts

@@ -115,15 +115,15 @@ interface Map<K, V> {
     readonly [Symbol.toStringTag]: string;
 }
 
-interface WeakMap<K extends object, V> {
+interface WeakMap<K extends WeakKey, V> {
     readonly [Symbol.toStringTag]: string;
 }
 
 interface Set<T> {
     readonly [Symbol.toStringTag]: string;
 }
 
-interface WeakSet<T extends object> {
+interface WeakSet<T extends WeakKey> {
     readonly [Symbol.toStringTag]: string;
 }
 

src/lib/es2021.weakref.d.ts

@@ -1,4 +1,4 @@
-interface WeakRef<T extends object> {
+interface WeakRef<T extends WeakKey> {
     readonly [Symbol.toStringTag]: "WeakRef";
 
     /**
@@ -15,7 +15,7 @@ interface WeakRefConstructor {
      * Creates a WeakRef instance for the given target object.
      * @param target The target object for the WeakRef instance.
      */
-    new<T extends object>(target: T): WeakRef<T>;
+    new<T extends WeakKey>(target: T): WeakRef<T>;
 }
 
 declare var WeakRef: WeakRefConstructor;

src/lib/es2023.collection.d.ts

@@ -0,0 +1,16 @@
+interface WeakKeyTypes {
+    symbol: symbol;
+}
+
+interface WeakSet<T extends WeakKey> {}
+
+interface WeakSetConstructor {
+    new <T extends WeakKey = WeakKey>(values?: readonly T[] | null): WeakSet<T>;
+}
+
+interface WeakMap<K extends WeakKey, V> {}
+
+interface WeakMapConstructor {
+    new <K extends WeakKey = WeakKey, V = any>(entries?: readonly [K, V][] | null): WeakMap<K, V>;
+    readonly prototype: WeakMap<WeakKey, any>;
+}

src/lib/es2023.d.ts

@@ -1,2 +1,4 @@
 /// <reference lib="es2022" />
 /// <reference lib="es2023.array" />
+/// <reference lib="es2023.collection" />
+/// <reference lib="es2023.weakref" />

src/lib/es2023.weakref.d.ts

@@ -0,0 +1,49 @@
+interface WeakKeyTypes {
+    symbol: symbol;
+}
+
+interface FinalizationRegistry<T> {
+    readonly [Symbol.toStringTag]: "FinalizationRegistry";
+
+    /**
+     * Registers an object with the registry.
+     * @param target The target object to register.
+     * @param heldValue The value to pass to the finalizer for this object. This cannot be the
+     * target object.
+     * @param unregisterToken The token to pass to the unregister method to unregister the target
+     * object. If provided (and not undefined), this must be an object. If not provided, the target
+     * cannot be unregistered.
+     */
+    registerSymbol(target: symbol, heldValue: T, unregisterToken?: symbol): void;
+
+    /**
+     * Unregisters an object from the registry.
+     * @param unregisterToken The token that was used as the unregisterToken argument when calling
+     * register to register the target object.
+     */
+    unregisterSymbol(unregisterToken: symbol): void;
+}
+
+interface FinalizationRegistryConstructor {
+    readonly prototype: FinalizationRegistry<any>;
+
+    /**
+     * Creates a finalization registry with an associated cleanup callback
+     * @param cleanupCallback The callback to call after an object in the registry has been reclaimed.
+     */
+    new<T>(cleanupCallback: (heldValue: T) => void): FinalizationRegistry<T>;
+}
+
+declare var FinalizationRegistry: FinalizationRegistryConstructor;
+
+interface WeakRef<T extends WeakKey> {
+    /**
+     * Returns the WeakRef instance's target object, or undefined if the target object has been
+     * reclaimed.
+     */
+     deref(): T | undefined;
+}
+
+interface WeakRefConstructor {
+    new<T extends WeakKey>(target: T): WeakRef<T>;
+}

src/lib/libs.json

@@ -65,6 +65,8 @@
         "es2022.string",
         "es2022.regexp",
         "es2023.array",
+        "es2023.collection",
+        "es2023.weakref",
         "esnext.intl",
         "decorators",
         "decorators.legacy",

tests/baselines/reference/acceptSymbolAsWeakType.js

@@ -0,0 +1,37 @@
+//// [acceptSymbolAsWeakType.ts]
+const s: symbol = Symbol('s');
+
+const ws = new WeakSet([s]);
+ws.add(s);
+ws.has(s);
+ws.delete(s);
+
+const wm = new WeakMap([[s, false]]);
+wm.set(s, true);
+wm.has(s);
+wm.get(s);
+wm.delete(s);
+
+const wr = new WeakRef(s);
+wr.deref();
+
+const f = new FinalizationRegistry<symbol>(() => {});
+f.registerSymbol(s, null);
+f.unregisterSymbol(s);
+
+//// [acceptSymbolAsWeakType.js]
+const s = Symbol('s');
+const ws = new WeakSet([s]);
+ws.add(s);
+ws.has(s);
+ws.delete(s);
+const wm = new WeakMap([[s, false]]);
+wm.set(s, true);
+wm.has(s);
+wm.get(s);
+wm.delete(s);
+const wr = new WeakRef(s);
+wr.deref();
+const f = new FinalizationRegistry(() => { });
+f.registerSymbol(s, null);
+f.unregisterSymbol(s);

tests/baselines/reference/dissallowSymbolAsWeakType.errors.txt

@@ -0,0 +1,99 @@
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(3,12): error TS2769: No overload matches this call.
+  Overload 1 of 2, '(iterable: Iterable<object>): WeakSet<object>', gave the following error.
+    Argument of type 'symbol[]' is not assignable to parameter of type 'Iterable<object>'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<symbol, any>' is not assignable to type 'IteratorResult<object, any>'.
+          Type 'IteratorYieldResult<symbol>' is not assignable to type 'IteratorResult<object, any>'.
+            Type 'IteratorYieldResult<symbol>' is not assignable to type 'IteratorYieldResult<object>'.
+              Type 'symbol' is not assignable to type 'object'.
+  Overload 2 of 2, '(values?: readonly object[]): WeakSet<object>', gave the following error.
+    Type 'symbol' is not assignable to type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(4,8): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(5,8): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(6,11): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(8,12): error TS2769: No overload matches this call.
+  Overload 1 of 2, '(iterable: Iterable<readonly [object, boolean]>): WeakMap<object, boolean>', gave the following error.
+    Argument of type '[symbol, false][]' is not assignable to parameter of type 'Iterable<readonly [object, boolean]>'.
+      The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+        Type 'IteratorResult<[symbol, false], any>' is not assignable to type 'IteratorResult<readonly [object, boolean], any>'.
+          Type 'IteratorYieldResult<[symbol, false]>' is not assignable to type 'IteratorResult<readonly [object, boolean], any>'.
+            Type 'IteratorYieldResult<[symbol, false]>' is not assignable to type 'IteratorYieldResult<readonly [object, boolean]>'.
+              Type '[symbol, false]' is not assignable to type 'readonly [object, boolean]'.
+                Type at position 0 in source is not compatible with type at position 0 in target.
+                  Type 'symbol' is not assignable to type 'object'.
+  Overload 2 of 2, '(entries?: readonly [object, boolean][]): WeakMap<object, boolean>', gave the following error.
+    Type 'symbol' is not assignable to type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(9,8): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(10,8): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(11,8): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(12,11): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(14,24): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(18,12): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+tests/cases/compiler/dissallowSymbolAsWeakType.ts(19,14): error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+
+
+==== tests/cases/compiler/dissallowSymbolAsWeakType.ts (12 errors) ====
+    const s: symbol = Symbol('s');
+
+    const ws = new WeakSet([s]);
+               ~~~~~~~~~~~~~~~~
+!!! error TS2769: No overload matches this call.
+!!! error TS2769:   Overload 1 of 2, '(iterable: Iterable<object>): WeakSet<object>', gave the following error.
+!!! error TS2769:     Argument of type 'symbol[]' is not assignable to parameter of type 'Iterable<object>'.
+!!! error TS2769:       The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2769:         Type 'IteratorResult<symbol, any>' is not assignable to type 'IteratorResult<object, any>'.
+!!! error TS2769:           Type 'IteratorYieldResult<symbol>' is not assignable to type 'IteratorResult<object, any>'.
+!!! error TS2769:             Type 'IteratorYieldResult<symbol>' is not assignable to type 'IteratorYieldResult<object>'.
+!!! error TS2769:               Type 'symbol' is not assignable to type 'object'.
+!!! error TS2769:   Overload 2 of 2, '(values?: readonly object[]): WeakSet<object>', gave the following error.
+!!! error TS2769:     Type 'symbol' is not assignable to type 'object'.
+    ws.add(s);
+           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    ws.has(s);
+           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    ws.delete(s);
+              ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+
+    const wm = new WeakMap([[s, false]]);
+               ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2769: No overload matches this call.
+!!! error TS2769:   Overload 1 of 2, '(iterable: Iterable<readonly [object, boolean]>): WeakMap<object, boolean>', gave the following error.
+!!! error TS2769:     Argument of type '[symbol, false][]' is not assignable to parameter of type 'Iterable<readonly [object, boolean]>'.
+!!! error TS2769:       The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
+!!! error TS2769:         Type 'IteratorResult<[symbol, false], any>' is not assignable to type 'IteratorResult<readonly [object, boolean], any>'.
+!!! error TS2769:           Type 'IteratorYieldResult<[symbol, false]>' is not assignable to type 'IteratorResult<readonly [object, boolean], any>'.
+!!! error TS2769:             Type 'IteratorYieldResult<[symbol, false]>' is not assignable to type 'IteratorYieldResult<readonly [object, boolean]>'.
+!!! error TS2769:               Type '[symbol, false]' is not assignable to type 'readonly [object, boolean]'.
+!!! error TS2769:                 Type at position 0 in source is not compatible with type at position 0 in target.
+!!! error TS2769:                   Type 'symbol' is not assignable to type 'object'.
+!!! error TS2769:   Overload 2 of 2, '(entries?: readonly [object, boolean][]): WeakMap<object, boolean>', gave the following error.
+!!! error TS2769:     Type 'symbol' is not assignable to type 'object'.
+    wm.set(s, true);
+           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    wm.has(s);
+           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    wm.get(s);
+           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    wm.delete(s);
+              ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+
+    const wr = new WeakRef(s);
+                           ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    wr.deref();
+
+    const f = new FinalizationRegistry(() => {});
+    f.register(s, null);
+               ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+    f.unregister(s);
+                 ~
+!!! error TS2345: Argument of type 'symbol' is not assignable to parameter of type 'object'.
+

tests/baselines/reference/dissallowSymbolAsWeakType.js

@@ -0,0 +1,38 @@
+//// [dissallowSymbolAsWeakType.ts]
+const s: symbol = Symbol('s');
+
+const ws = new WeakSet([s]);
+ws.add(s);
+ws.has(s);
+ws.delete(s);
+
+const wm = new WeakMap([[s, false]]);
+wm.set(s, true);
+wm.has(s);
+wm.get(s);
+wm.delete(s);
+
+const wr = new WeakRef(s);
+wr.deref();
+
+const f = new FinalizationRegistry(() => {});
+f.register(s, null);
+f.unregister(s);
+
+
+//// [dissallowSymbolAsWeakType.js]
+const s = Symbol('s');
+const ws = new WeakSet([s]);
+ws.add(s);
+ws.has(s);
+ws.delete(s);
+const wm = new WeakMap([[s, false]]);
+wm.set(s, true);
+wm.has(s);
+wm.get(s);
+wm.delete(s);
+const wr = new WeakRef(s);
+wr.deref();
+const f = new FinalizationRegistry(() => { });
+f.register(s, null);
+f.unregister(s);

tests/cases/compiler/acceptSymbolAsWeakType.ts

@@ -0,0 +1,22 @@
+// @lib: esnext
+// @target: esnext
+
+const s: symbol = Symbol('s');
+
+const ws = new WeakSet([s]);
+ws.add(s);
+ws.has(s);
+ws.delete(s);
+
+const wm = new WeakMap([[s, false]]);
+wm.set(s, true);
+wm.has(s);
+wm.get(s);
+wm.delete(s);
+
+const wr = new WeakRef(s);
+wr.deref();
+
+const f = new FinalizationRegistry<symbol>(() => {});
+f.registerSymbol(s, null);
+f.unregisterSymbol(s);