Add tests for regular and well-known Symbols as weak values

This adds tests to WeakMap, WeakSet, WeakRef, and FinalizationRegistry for
Symbols as weakly-held values. Regular symbols and well-known symbols are
both tested. These tests correspond to existing tests for Objects as
weakly-held values, but are put in separate files so that they can be
filtered out with the "symbols-as-weakmap-keys" feature flag.

Registered symbols are not allowed; this is already tested in the "cannot-
be-held-weakly" tests.

See: #2850

test/built-ins/FinalizationRegistry/prototype/register/heldValue-same-as-target.js

@@ -10,10 +10,26 @@ info: |
   2. Perform ? RequireInternalSlot(_finalizationRegistry_, [[Cells]]).
   3. If CanBeHeldWeakly(_target_) is *false*, throw a *TypeError* exception.
   4. If SameValue(_target_, _heldValue_) is *true*, throw a *TypeError* exception.
-features: [FinalizationRegistry]
+features: [FinalizationRegistry, Symbol]
 ---*/
 
 var finalizationRegistry = new FinalizationRegistry(function() {});
 
 var target = {};
 assert.throws(TypeError, () => finalizationRegistry.register(target, target));
+
+// The following will throw regardless of whether the implementation supports
+// Symbols as weak values. Step 3 if no, Step 4 if yes.
+
+var symbolTarget = Symbol('a description');
+assert.throws(
+  TypeError,
+  () => finalizationRegistry.register(symbolTarget, symbolTarget),
+  'target and heldValue are the same regular symbol'
+);
+
+assert.throws(
+  TypeError,
+  () => finalizationRegistry.register(Symbol.hasInstance, Symbol.hasInstance),
+  'target and heldValue are the same well-known symbol'
+);

test/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-symbol.js

@@ -0,0 +1,73 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-finalization-registry.prototype.register
+description: Return undefined after registering a Symbol
+info: |
+  FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] )
+  8. Return *undefined*.
+features: [FinalizationRegistry, Symbol, symbols-as-weakmap-keys]
+---*/
+
+var fn = function() {};
+var reg = new FinalizationRegistry(fn);
+
+var target = Symbol('a description');
+assert.sameValue(reg.register(target), undefined, 'Register a regular symbol');
+assert.sameValue(reg.register(target), undefined, 'Register the same symbol again');
+assert.sameValue(reg.register(target), undefined, 'Register the same symbol a third time');
+
+assert.sameValue(
+  reg.register(Symbol('a description')),
+  undefined,
+  'Register another symbol with the same description'
+);
+assert.sameValue(
+  reg.register(Symbol('a different description')),
+  undefined,
+  'Register another symbol with another description'
+);
+
+assert.sameValue(
+  reg.register(target, undefined, Symbol('unregister token')),
+  undefined,
+  'Register a regular symbol with a symbol unregister token'
+);
+assert.sameValue(
+  reg.register(target, undefined, target),
+  undefined,
+  'Register a regular symbol with itself as the unregister token'
+);
+
+assert.sameValue(
+  reg.register(target, undefined, undefined),
+  undefined,
+  'Register a regular symbol with explicit undefined unregister token'
+);
+
+assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register a well-known symbol');
+assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register the same well-known symbol again');
+assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register the same well-known symbol a third time');
+
+assert.sameValue(
+  reg.register(target, undefined, Symbol.hasInstance),
+  undefined,
+  'Register a regular symbol with a well-known symbol unregister token'
+);
+assert.sameValue(
+  reg.register(Symbol.hasInstance, undefined, Symbol.iterator),
+  undefined,
+  'Register a well-known symbol with a different well-known symbol as unregister token'
+);
+assert.sameValue(
+  reg.register(Symbol.hasInstance, undefined, Symbol.hasInstance),
+  undefined,
+  'Register a well-known symbol with itself as the unregister token'
+);
+
+assert.sameValue(
+  reg.register(Symbol.hasInstance, undefined, undefined),
+  undefined,
+  'Register a well-known symbol with explicit undefined unregister token'
+);

test/built-ins/FinalizationRegistry/prototype/unregister/unregister-symbol-token.js

@@ -0,0 +1,61 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-finalization-registry.prototype.unregister
+description: >
+  Return boolean values indicating unregistering of values with Symbol token
+info: |
+  FinalizationRegistry.prototype.unregister ( _unregisterToken_ )
+  4. Let _removed_ be *false*.
+  5. For each Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] }
+    _cell_ of _finalizationRegistry_.[[Cells]], do
+    a. If _cell_.[[UnregisterToken]] is not ~empty~ and
+      SameValue(_cell_.[[UnregisterToken]], _unregisterToken_) is *true*, then
+      i. Remove _cell_ from _finalizationRegistry_.[[Cells]].
+      ii. Set _removed_ to *true*.
+  6. Return _removed_.
+features: [FinalizationRegistry, Symbol, symbols-as-weakmap-keys]
+---*/
+
+var fn = function() {};
+var reg = new FinalizationRegistry(fn);
+
+var target1 = {};
+var target2 = {};
+var target3 = {};
+var token = Symbol('unregister');
+
+assert.sameValue(reg.unregister(token), false, 'unregistering regular symbol from empty registry');
+assert.sameValue(reg.unregister(Symbol.hasInstance), false, 'unregistering well-known symbol from empty registry');
+
+reg.register(target1, undefined, token);
+reg.register(target1, undefined, token); // Repeat registering on purpose
+reg.register(target2, undefined, Symbol.hasInstance);
+reg.register(target3, undefined, Symbol.hasInstance);
+
+assert.sameValue(reg.unregister(token), true, 'unregistering regular symbol from finalization registry');
+assert.sameValue(reg.unregister(token), false, 'unregistering regular symbol again from finalization registry');
+assert.sameValue(
+  reg.unregister(Symbol.hasInstance),
+  true,
+  'unregistering well-known symbol to remove target2 and target3'
+);
+assert.sameValue(
+  reg.unregister(Symbol.hasInstance),
+  false,
+  'unregistering well-known again from finalization registry'
+);
+
+// Notice these assertions take advantage of adding targets previously added
+// with a token, but now they have no token so it won't be used to remove them.
+reg.register(target1, token); // heldValue, not unregisterToken
+reg.register(target2, Symbol.hasInstance); // heldValue, not unregisterToken
+reg.register(target3);
+
+assert.sameValue(reg.unregister(token), false, 'nothing to remove with regular symbol unregister token');
+assert.sameValue(
+  reg.unregister(Symbol.hasInstance),
+  false,
+  'nothing to remove with well-known symbol unregister token'
+);

test/built-ins/WeakMap/iterable-with-symbol-keys.js

@@ -0,0 +1,45 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap-iterable
+description: >
+  Returns the new WeakMap adding entries from the iterable parameter, with
+  Symbol keys.
+info: |
+  WeakMap ( [ _iterable_ ] )
+  5. Let _adder_ be ? Get(_map_, *"set"*).
+  6. Return ? AddEntriesFromIterable(_map_, _iterable_, _adder_).
+
+  AddEntriesFromIterable:
+  3. Repeat,
+    i. Let _status_ be Completion(Call(_adder_, _target_, « _k_, _v_ »)).
+
+  WeakMap.prototype.set( _key_, _value_ ):
+  6. Let _p_ be the Record {[[Key]]: _key_, [[Value]]: _value_}.
+  7. Append _p_ as the last element of _entries_.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var sym = Symbol('a description');
+var results = [];
+var set = WeakMap.prototype.set;
+WeakMap.prototype.set = function(key, value) {
+  results.push({
+    _this: this,
+    key: key,
+    value: value
+  });
+  return set.call(this, key, value);
+};
+var map = new WeakMap([
+  [sym, 42],
+  [Symbol.hasInstance, 43],
+]);
+
+assert.sameValue(results.length, 2, 'Called set() for each entry');
+assert.sameValue(results[0].key, sym, 'Adds object in order - first key, regular symbol');
+assert.sameValue(results[0].value, 42, 'Adds object in order - first value');
+assert.sameValue(results[0]._this, map, 'Adds object in order - this');
+assert.sameValue(results[1].key, Symbol.hasInstance, 'Adds object in order - second key, well-known symbol');
+assert.sameValue(results[1].value, 43, 'Adds object in order - second value');
+assert.sameValue(results[1]._this, map, 'Adds object in order - this');

test/built-ins/WeakMap/prototype/delete/delete-entry-with-symbol-key-initial-iterable.js

@@ -0,0 +1,35 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.delete
+description: >
+  Delete an entry with a Symbol key, added from initial iterable.
+info: |
+  WeakMap.prototype.delete ( _key_ )
+  3. Let _entries_ be the List that is _M_.[[WeakMapData]].
+  4. If CanBeHeldWeakly(_key_) is *false*, return *false*.
+  5. For each Record {[[Key]], [[Value]]} _p_ of _entries_, do
+    a. If _p_.[[Key]] is not ~empty~ and SameValue(_p_.[[Key]], _key_) is
+      *true*, then
+      i. Set _p_.[[Key]] to ~empty~.
+      ii. Set _p_.[[Value]] to ~empty~.
+      iii. Return *true*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var map = new WeakMap([
+  [foo, 42],
+  [bar, 43],
+  [Symbol.hasInstance, 44],
+]);
+
+var result = map.delete(foo);
+assert(!map.has(foo), 'Regular symbol was deleted from map');
+assert(map.has(bar), "Symbols with the same description don't alias to each other");
+assert.sameValue(result, true, 'delete() returns true for regular symbol');
+
+result = map.delete(Symbol.hasInstance);
+assert(!map.has(Symbol.hasInstance), 'Well-known symbol was deleted from map');
+assert.sameValue(result, true, 'delete() returns true for well-known symbol');

test/built-ins/WeakMap/prototype/delete/delete-entry-with-symbol-key.js

@@ -0,0 +1,38 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.delete
+description: >
+  Delete an entry with a Symbol key.
+info: |
+  WeakMap.prototype.delete ( _key_ )
+  3. Let _entries_ be the List that is _M_.[[WeakMapData]].
+  4. If CanBeHeldWeakly(_key_) is *false*, return *false*.
+  5. For each Record {[[Key]], [[Value]]} _p_ of _entries_, do
+    a. If _p_.[[Key]] is not ~empty~ and SameValue(_p_.[[Key]], _key_) is
+      *true*, then
+      i. Set _p_.[[Key]] to ~empty~.
+      ii. Set _p_.[[Value]] to ~empty~.
+      iii. Return *true*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var map = new WeakMap();
+
+map.set(foo, 42);
+map.set(bar, 43);
+
+var result = map.delete(foo);
+
+assert(!map.has(foo), 'Regular symbol was deleted from map');
+assert(map.has(bar), "Symbols with the same description don't alias each other");
+assert.sameValue(result, true, 'delete() returns true for regular symbol');
+
+map.set(Symbol.hasInstance, 44);
+
+result = map.delete(Symbol.hasInstance);
+
+assert(!map.has(Symbol.hasInstance), 'Well-known symbol was deleted from map');
+assert.sameValue(result, true, 'delete() returns true for well-known symbol');

test/built-ins/WeakMap/prototype/delete/returns-false-when-symbol-key-not-present.js

@@ -0,0 +1,22 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.delete
+description: >
+  Return false if a Symbol key is not in the WeakMap.
+info: |
+  WeakMap.prototype.delete ( _key_ )
+  6. Return *false*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var map = new WeakMap();
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var baz = Symbol('another description');
+
+map.set(foo, 42);
+
+assert.sameValue(map.delete(baz), false, 'Regular symbol key not present')
+assert.sameValue(map.delete(bar), false, "Symbols with the same description don't alias to each other");
+assert.sameValue(map.delete(Symbol.hasInstance), false, 'Well-known symbol key not present');

test/built-ins/WeakMap/prototype/get/returns-undefined-with-symbol-key.js

@@ -0,0 +1,34 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.get
+description: >
+  Returns undefined when a Symbol key is not on the WeakMap object.
+info: |
+  WeakMap.prototype.get ( _key_ )
+  3. Let _entries_ be the List that is _M_.[[WeakMapData]].
+  4. If CanBeHeldWeakly(_key_) is *false*, return *undefined*.
+  5. For each Record {[[Key]], [[Value]]} _p_ of _entries_, do
+    a. If _p_.[[Key]] is not empty and SameValue(_p_.[[Key]], _key_) is *true*,
+      return _p_.[[Value]].
+  6. Return *undefined*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var map = new WeakMap();
+var key = Symbol('a description');
+
+assert.sameValue(map.get(key), undefined, 'returns undefined for regular symbol on initially empty map');
+assert.sameValue(
+  map.get(Symbol.hasInstance),
+  undefined,
+  'returns undefined for well-known symbol on initially empty map'
+);
+
+map.set(key, 1);
+map.set(Symbol.hasInstance, 2);
+map.delete(key);
+map.delete(Symbol.hasInstance);
+
+assert.sameValue(map.get(key), undefined, 'returns undefined for deleted regular symbol');
+assert.sameValue(map.get(Symbol.hasInstance), undefined, 'returns undefined for deleted well-known symbol');

test/built-ins/WeakMap/prototype/get/returns-value-with-symbol-key.js

@@ -0,0 +1,32 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.get
+description: >
+  Returns the value from the specified Symbol key
+info: |
+  WeakMap.prototype.get ( _key_ )
+  3. Let _entries_ be the List that is _M_.[[WeakMapData]].
+  4. If CanBeHeldWeakly(_key_) is *false*, return *undefined*.
+  5. For each Record {[[Key]], [[Value]]} _p_ of _entries_, do
+    a. If _p_.[[Key]] is not ~empty~ and SameValue(_p_.[[Key]], _key_) is
+      *true*, return _p_.[[Value]].
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var baz = Symbol('different description');
+var map = new WeakMap([
+  [foo, 0],
+]);
+
+assert.sameValue(map.get(foo), 0, 'Regular symbol as key, added in constructor');
+
+map.set(bar, 1);
+map.set(baz, 2);
+assert.sameValue(map.get(baz), 2, 'Regular symbol as key, added with set()');
+assert.sameValue(map.get(bar), 1, "Symbols with the same description don't overwrite each other");
+
+map.set(Symbol.hasInstance, 3);
+assert.sameValue(map.get(Symbol.hasInstance), 3, 'Well-known symbol as key');

test/built-ins/WeakMap/prototype/has/returns-false-when-symbol-key-not-present.js

@@ -0,0 +1,28 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.has
+description: >
+  Return false when a Symbol key is not present in the WeakMap entries.
+info: |
+  WeakMap.prototype.has ( _key_ )
+  6. Return *false*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var map = new WeakMap();
+
+assert.sameValue(map.has(foo), false, 'Map is initially empty of regular symbol');
+assert.sameValue(map.has(Symbol.hasInstance), false, 'Map is initially empty of well-known symbol');
+
+map.set(foo, 1);
+assert.sameValue(map.has(bar), false, "Symbols with the same description don't alias each other");
+
+map.delete(foo);
+assert.sameValue(map.has(foo), false, 'Map is empty again of regular symbol after deleting');
+
+map.set(Symbol.hasInstance, 2);
+map.delete(Symbol.hasInstance);
+assert.sameValue(map.has(Symbol.hasInstance), false, 'Map is empty again of well-known symbol after deleting');

test/built-ins/WeakMap/prototype/has/returns-true-when-symbol-key-present.js

@@ -0,0 +1,27 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.has
+description: >
+  Returns true when an Object key is present in the WeakMap entries list.
+info: |
+  WeakMap.prototype.has ( _key_ )
+  5. For each Record {[[Key]], [[Value]]} _p_ of _entries_, do
+    a. If _p_.[[Key]] is not ~empty~ and SameValue(_p_.[[Key]], _key_) is
+      *true*, return *true*.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var map = new WeakMap();
+
+map.set(foo, 1);
+map.set(bar, 2);
+assert.sameValue(map.has(foo), true, "Regular symbol as key");
+
+map.delete(foo);
+assert.sameValue(map.has(bar), true, "Symbols with the same description don't alias each other");
+
+map.set(Symbol.hasInstance, 3);
+assert.sameValue(map.has(Symbol.hasInstance), true, "Well-known symbol as key");

test/built-ins/WeakMap/prototype/set/adds-symbol-element.js

@@ -0,0 +1,23 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakmap.prototype.set
+description: Adds a value with a Symbol key.
+info: |
+  WeakMap.prototype.set ( _key_, _value_ )
+  6. Let _p_ be the Record {[[Key]]: _key_, [[Value]]: _value_}.
+  7. Append _p_ as the last element of _entries_.
+features: [Symbol, WeakMap, symbols-as-weakmap-keys]
+---*/
+
+var map = new WeakMap();
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+
+map.set(foo, 1);
+map.set(bar, 2);
+map.set(Symbol.hasInstance, 3);
+
+assert(map.has(bar), 'Regular symbol as key');
+assert.sameValue(map.get(foo), 1, "Symbols with the same description don't overwrite each other");
+assert(map.has(Symbol.hasInstance), 'Well-known symbol as key');

test/built-ins/WeakRef/prototype/deref/return-symbol-target.js

@@ -0,0 +1,26 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-weak-ref.prototype.deref
+description: Return a Symbol target if weakRef.[[Target]] is not empty
+info: |
+  WeakRef.prototype.deref ()
+  3. Return WeakRefDeref(_weakRef_).
+
+  WeakRefDeref( _weakRef_ ):
+  1. Let _target_ be _weakRef_.[[WeakRefTarget]].
+  2. If _target_ is not ~empty~,
+    a. Perform AddToKeptObjects(_target_).
+    b. Return _target_.
+features: [Symbol, WeakRef, symbols-as-weakmap-keys]
+---*/
+
+var target = Symbol('a description');
+var wref = new WeakRef(target);
+
+assert.sameValue(wref.deref(), target, 'returns a regular symbol target');
+
+var wref2 = new WeakRef(Symbol.hasInstance);
+
+assert.sameValue(wref2.deref(), Symbol.hasInstance, 'returns a well-known symbol target');

test/built-ins/WeakRef/returns-new-object-from-constructor-with-symbol-target.js

@@ -0,0 +1,29 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-weak-ref-target
+description: >
+  Returns a new ordinary object from the WeakRef constructor when called with a
+  Symbol target
+info: |
+  WeakRef ( _target_ )
+  3. Let _weakRef_ be ? OrdinaryCreateFromConstructor(NewTarget,
+    *"%WeakRefPrototype%"*, « [[WeakRefTarget]] »).
+  4. Perfom AddToKeptObjects(_target_).
+  5. Set _weakRef_.[[WeakRefTarget]] to _target_.
+  6. Return _weakRef_.
+features: [Symbol, WeakRef, symbols-as-weakmap-keys]
+---*/
+
+var target = Symbol('a description');
+var wr = new WeakRef(target);
+
+assert.sameValue(wr instanceof WeakRef, true, 'object is instanceof WeakRef');
+assert.sameValue(Object.getPrototypeOf(wr), WeakRef.prototype, 'prototype is WeakRef.prototype');
+
+wr = new WeakRef(Symbol.hasInstance);
+
+assert.sameValue(wr instanceof WeakRef, true, 'object is instanceof WeakRef');
+assert.sameValue(Object.getPrototypeOf(wr), WeakRef.prototype, 'prototype is WeakRef.prototype');
+

test/built-ins/WeakSet/iterable-with-symbol-values.js

@@ -0,0 +1,33 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakset-iterable
+description: >
+  Returns the new WeakSet adding Symbol values from the iterable parameter.
+info: |
+  WeakSet ( [ _iterable_ ] )
+  8. Repeat,
+    d. Let _status_ be Completion(Call(_adder_, _set_, « _nextValue_ »)).
+
+  WeakSet.prototype.add ( _value_ ):
+  6. Append _value_ as the last element of _entries_.
+features: [Symbol, WeakSet, symbols-as-weakmap-keys]
+---*/
+
+var first = Symbol('a description');
+var second = Symbol('a description');
+var added = [];
+var realAdd = WeakSet.prototype.add;
+WeakSet.prototype.add = function(value) {
+  added.push(value);
+  return realAdd.call(this, value);
+};
+var s = new WeakSet([first, second, Symbol.hasInstance]);
+
+assert.compareArray(
+  added,
+  [first, second, Symbol.hasInstance],
+  "add() was called 3 times, on the two unregistered and one well-known symbols in order"
+);
+
+WeakSet.prototype.add = realAdd;

test/built-ins/WeakSet/prototype/add/adds-symbol-element.js

@@ -0,0 +1,24 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakset.prototype.add
+description: Adds a Symbol value.
+info: |
+  WeakSet.prototype.add ( _value_ )
+  6. Append _value_ as the last element of _entries_.
+features: [Symbol, WeakSet, symbols-as-weakmap-keys]
+---*/
+
+var s = new WeakSet();
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var baz = Symbol('a different description');
+
+s.add(foo);
+s.add(baz);
+s.add(Symbol.hasInstance);
+
+assert(s.has(foo), 'Regular symbol');
+assert(!s.has(bar), "Symbols with the same description don't alias each other");
+assert(s.has(baz), 'Regular symbol with different description');
+assert(s.has(Symbol.hasInstance), 'Well-known symbol');

test/built-ins/WeakSet/prototype/delete/delete-symbol-entry.js

@@ -0,0 +1,31 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakset.prototype.delete
+description: >
+  Delete an entry that is a Symbol
+info: |
+  WeakSet.prototype.delete ( _value_ )
+  4. Let _entries_ be the List that is _S_.[[WeakSetData]].
+  5. For each element _e_ of _entries_, do
+    a. If _e_ is not ~empty~ and SameValue(_e_, _value_) is *true*, then
+      i. Replace the element of _entries_ whose value is _e_ with an element
+        whose value is ~empty~.
+      ii. Return *true*.
+features: [Symbol, WeakSet, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var s = new WeakSet();
+
+s.add(foo);
+s.add(bar);
+s.add(Symbol.hasInstance);
+
+assert.sameValue(s.delete(foo), true, 'Returns true for regular symbol');
+assert(!s.has(foo), 'Regular symbol is removed from set');
+assert(s.has(bar), 'Symbols with the same description are not aliased to each other');
+
+assert.sameValue(s.delete(Symbol.hasInstance), true, 'Returns true for well-known symbol');
+assert(!s.has(Symbol.hasInstance), 'Well-known symbol is removed from set');

test/built-ins/WeakSet/prototype/has/returns-false-when-symbol-value-not-present.js

@@ -0,0 +1,26 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakset.prototype.has
+description: >
+  Return false when a Symbol value is not present in the WeakSet entries.
+info: |
+  WeakSet.prototype.has ( _value_ )
+  6. Return *false*.
+features: [Symbol, WeakSet, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var bar = Symbol('a description');
+var s = new WeakSet();
+
+assert.sameValue(s.has(foo), false, 'Set is initially empty of regular symbol');
+assert.sameValue(s.has(Symbol.hasInstance), false, 'Set is initially empty of well-known symbol');
+
+s.add(foo);
+assert.sameValue(s.has(bar), false, 'Symbols with the same description are not aliased to each other');
+
+s.delete(foo);
+assert.sameValue(s.has(foo), false, 'Set is again empty of regular symbol after deleting');
+s.delete(Symbol.hasInstance);
+assert.sameValue(s.has(Symbol.hasInstance), false, 'Set is again empty of well-known symbol after deleting');

test/built-ins/WeakSet/prototype/has/returns-true-when-symbol-value-present.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-weakset.prototype.has
+description: >
+  Returns true when a Symbol value is present in the WeakSet entries list.
+info: |
+  WeakSet.prototype.has ( _value_ )
+  5. For each element _e_ of _entries_, do
+    a. If _e_ is not ~empty~ and SameValue(_e_, _value_) is *true*, return *true*.
+features: [Symbol, WeakSet, symbols-as-weakmap-keys]
+---*/
+
+var foo = Symbol('a description');
+var s = new WeakSet();
+
+s.add(foo);
+assert.sameValue(s.has(foo), true, 'Regular symbol as value');
+
+s.add(Symbol.hasInstance);
+assert.sameValue(s.has(Symbol.hasInstance), true, 'Well-known symbol as value');