Attachment #8558567 for bug #1108930

Attachment #8558567: Part 2: Call Set with new. for bug #1108930

View | Details | Raw Unified | Return to bug 1108930
Collapse All | Expand All





  //   |prop| which is present in the basis with value |value|.
  //
  // - extra(prop): Called when the subject has a property named |prop|, but the
  //   basis has no such property. This should return a walker that can check
  //   the subject's value.
  function makeBasisChecker({compare, missing, extra}) {
    return function makeWalker(basis) {
      if (typeof basis === 'object') {
        var unvisited = new Set(Object.getOwnPropertyNames(basis));
        return {
          enter: prop => {
            unvisited.delete(prop);
            if (prop in basis) {
              return makeWalker(basis[prop]);
            } else {
              return extra(prop);
            }

(-)a/js/src/jit-test/tests/auto-regress/bug771027.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

// |jit-test| error:TypeError

// |jit-test| error:TypeError

// Binary: cache/js-dbg-32-b6aa44d8f11f-linux

// Binary: cache/js-dbg-32-b6aa44d8f11f-linux

// Flags:

// Flags:

//

//

Array.prototype.iterator = (function() { { while(0) function Uint8ClampedArray() {  } } });

Array.prototype.iterator = (function() { { while(0) function Uint8ClampedArray() {  } } });

assertEq(Set(["testing", "testing", 123]).size(), 2);

assertEq(new Set(["testing", "testing", 123]).size(), 2);

(-)a/js/src/jit-test/tests/basic/bug797496.js (-2 / +2 lines)

Line	Link Here

Lines 1-8	Link Here

// |jit-test| error: TypeError

// |jit-test| error: TypeError

var set = Set(['a']);

var set = new Set(['a']);

var n = 5;

var n = 5;

for (let v of set) {

for (let v of set) {

    if (n === 0)

    if (n === 0)

        break;

        break;

    let g = set(Set(0xffffffff, n), 1);

    let g = set(new Set(0xffffffff, n), 1);

(-)a/js/src/jit-test/tests/basic/spread-array.js (-1 / +1 lines)

Line	Link Here

Lines 14-30 assertEqArray([,,...[1, 2, 3],,,,], [,,1	Link Here

assertEqArray([...[1, 2, 3],,,,...[]], [1,2,3,,,,]);

assertEqArray([...[1, 2, 3],,,,...[]], [1,2,3,,,,]);

assertEqArray([...[undefined]], [undefined]);

assertEqArray([...[undefined]], [undefined]);

// other iterable objects

// other iterable objects

assertEqArray([...new Int32Array([1, 2, 3])], [1, 2, 3]);

assertEqArray([...new Int32Array([1, 2, 3])], [1, 2, 3]);

assertEqArray([..."abc"], ["a", "b", "c"]);

assertEqArray([..."abc"], ["a", "b", "c"]);

assertEqArray([...[1, 2, 3][Symbol.iterator]()], [1, 2, 3]);

assertEqArray([...[1, 2, 3][Symbol.iterator]()], [1, 2, 3]);

assertEqArray([...Set([1, 2, 3])], [1, 2, 3]);

assertEqArray([...new Set([1, 2, 3])], [1, 2, 3]);

assertEqArray([...new Map([["a", "A"], ["b", "B"], ["c", "C"]])].map(([k, v]) => k + v), ["aA", "bB", "cC"]);

assertEqArray([...new Map([["a", "A"], ["b", "B"], ["c", "C"]])].map(([k, v]) => k + v), ["aA", "bB", "cC"]);

let itr = {};

let itr = {};

itr[Symbol.iterator] = function () {

itr[Symbol.iterator] = function () {

    return {

    return {

        i: 1,

        i: 1,

        next: function() {

        next: function() {

            if (this.i < 4)

            if (this.i < 4)

                return { value: this.i++, done: false };

                return { value: this.i++, done: false };





try {             // line0 + 1
  eval(...["("]); // line0 + 2
} catch (e) {
  assertEq(e.lineNumber, 1);
}

// other iterable objects
assertEq(eval(...["a + b"][Symbol.iterator]()), 11);
assertEq(eval(...new Set(["a + b"])), 11);
let itr = {};
itr[Symbol.iterator] = function() {
    return {
        i: 0,
        next: function() {
            this.i++;
            if (this.i == 1)
                return { value: "a + b", done: false };






function checkCommon(f) {
  assertEqArray(f.apply(null, ...[[1, 2, 3]]), [1, 2, 3]);
  assertEqArray(f.apply(...[null], [1, 2, 3]), [1, 2, 3]);
  assertEqArray(f.apply(...[null], ...[[1, 2, 3]]), [1, 2, 3]);
  assertEqArray(f.apply(...[null, [1, 2, 3]]), [1, 2, 3]);

  // other iterable objects
  assertEqArray(f.apply(...new Set([null, [1, 2, 3]])), [1, 2, 3]);
  assertEqArray(f.apply(...[null, [1, 2, 3]][Symbol.iterator]()), [1, 2, 3]);
  let itr = {};
  itr[Symbol.iterator] = function() {
      return {
          i: 0,
          next: function() {
              this.i++;
              if (this.i == 1)





  assertEq(makeFn("1, ...[2, 3, 4], 5")(f), 5);

  assertEq(makeFn("...[undefined]")(f), 1);

  // other iterable objects
  assertEq(makeFn("...arg")(f, new Int32Array([1, 2, 3])), 3);
  assertEq(makeFn("...arg")(f, "abc"), 3);
  assertEq(makeFn("...arg")(f, [1, 2, 3][Symbol.iterator]()), 3);
  assertEq(makeFn("...arg")(f, new Set([1, 2, 3])), 3);
  assertEq(makeFn("...arg")(f, new Map([["a", "A"], ["b", "B"], ["c", "C"]])), 3);
  let itr = {};
  itr[Symbol.iterator] = function() {
      return {
          i: 1,
          next: function() {
              if (this.i < 4)
                  return { value: this.i++, done: false };

(-)a/js/src/jit-test/tests/basic/spread-call.js (-1 / +1 lines)

Line	Link Here

Lines 12-28 function checkCommon(f, makeFn) {	Link Here

  assertEqArray(makeFn("1, ...[2], ...[3]")(f), [1, 2, 3]);

  assertEqArray(makeFn("1, ...[2], ...[3]")(f), [1, 2, 3]);

  assertEqArray(makeFn("1, ...[2, 3]")(f), [1, 2, 3]);

  assertEqArray(makeFn("1, ...[2, 3]")(f), [1, 2, 3]);

  assertEqArray(makeFn("1, ...[], 2, 3")(f), [1, 2, 3]);

  assertEqArray(makeFn("1, ...[], 2, 3")(f), [1, 2, 3]);

  // other iterable objects

  // other iterable objects

  assertEqArray(makeFn("...arg")(f, new Int32Array([1, 2, 3])), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, new Int32Array([1, 2, 3])), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, "abc"), ["a", "b", "c"]);

  assertEqArray(makeFn("...arg")(f, "abc"), ["a", "b", "c"]);

  assertEqArray(makeFn("...arg")(f, [1, 2, 3][Symbol.iterator]()), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, [1, 2, 3][Symbol.iterator]()), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, Set([1, 2, 3])), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, new Set([1, 2, 3])), [1, 2, 3]);

  assertEqArray(makeFn("...arg")(f, new Map([["a", "A"], ["b", "B"], ["c", "C"]])).map(([k, v]) => k + v), ["aA", "bB", "cC"]);

  assertEqArray(makeFn("...arg")(f, new Map([["a", "A"], ["b", "B"], ["c", "C"]])).map(([k, v]) => k + v), ["aA", "bB", "cC"]);

  let itr = {};

  let itr = {};

  itr[Symbol.iterator] = function() {

  itr[Symbol.iterator] = function() {

      return {

      return {

          i: 1,

          i: 1,

          next: function() {

          next: function() {

              if (this.i < 4)

              if (this.i < 4)

                  return { value: this.i++, done: false };

                  return { value: this.i++, done: false };





load(libdir + "asserts.js");
load(libdir + "eqArrayHelper.js");
load(libdir + "iteration.js");

var g = newGlobal();

var iterator_fn = Map.prototype[Symbol.iterator];
assertThrowsInstanceOf(function () { iterator_fn.call({}); }, TypeError);
assertThrowsInstanceOf(function () { iterator_fn.call(new Set()); }, TypeError);
var mapw = g.eval("new Map([['x', 1], ['y', 2]])");
assertEqArray(iterator_fn.call(mapw).next().value, ["x", 1]);

var next_fn = new Map()[Symbol.iterator]().next;
assertThrowsInstanceOf(function () { next_fn.call({}); }, TypeError);
assertThrowsInstanceOf(function () { next_fn.call(new Set()[Symbol.iterator]()); }, TypeError);
var iterw = mapw[Symbol.iterator]();
assertEqArray(next_fn.call(iterw).value, ["x", 1]);
assertEqArray(next_fn.call(iterw).value, ["y", 2]);
assertEq(next_fn.call(iterw).done, true);

(-)a/js/src/jit-test/tests/collections/Set-add-size.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// set.add(v) increments set.size iff the set did not already contain v.

// set.add(v) increments set.size iff the set did not already contain v.

var s = Set();

var s = new Set();

for (var i = 0; i < 10; i++) {

for (var i = 0; i < 10; i++) {

    assertEq(s.size, i);

    assertEq(s.size, i);

    s.add(i);

    s.add(i);

for (var i = 0; i < 10; i++) {

for (var i = 0; i < 10; i++) {

    assertEq(s.size, 10);

    assertEq(s.size, 10);

    s.add(i);

    s.add(i);

(-)a/js/src/jit-test/tests/collections/Set-clear-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

// Clearing an empty Set has no effect.

// Clearing an empty Set has no effect.

var s = Set();

var s = new Set();

for (var i = 0; i < 2; i++) {

for (var i = 0; i < 2; i++) {

    s.clear();

    s.clear();

    assertEq(s.size, 0);

    assertEq(s.size, 0);

    assertEq(s.has(undefined), false);

    assertEq(s.has(undefined), false);

(-)a/js/src/jit-test/tests/collections/Set-clear-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Clearing a Set removes its elements; the Set remains usable afterwards.

// Clearing a Set removes its elements; the Set remains usable afterwards.

var s = Set(["x", "y", "z", "z", "y"]);

var s = new Set(["x", "y", "z", "z", "y"]);

assertEq(s.size, 3);

assertEq(s.size, 3);

s.clear();

s.clear();

assertEq(s.size, 0);

assertEq(s.size, 0);

assertEq(s.has("x"), false);

assertEq(s.has("x"), false);

assertEq(s.delete("x"), false);

assertEq(s.delete("x"), false);

assertEq(s.has("z"), false);

assertEq(s.has("z"), false);

for (var v of s)

for (var v of s)

    throw "FAIL";  // shouldn't be any elements

    throw "FAIL";  // shouldn't be any elements

(-)a/js/src/jit-test/tests/collections/Set-clear-3.js (-1 / +1 lines)

Line	Link Here

Lines 1-10	Link Here

// Clearing a Set with a nontrivial number of elements works.

// Clearing a Set with a nontrivial number of elements works.

var s = Set();

var s = new Set();

for (var i = 0; i < 100; i++)

for (var i = 0; i < 100; i++)

    s.add(i);

    s.add(i);

assertEq(s.size, i);

assertEq(s.size, i);

s.clear();

s.clear();

assertEq(s.size, 0);

assertEq(s.size, 0);

s.add(12);

s.add(12);

assertEq(s.has(12), true);

assertEq(s.has(12), true);

(-)a/js/src/jit-test/tests/collections/Set-clear-4.js (-1 / +1 lines)

Line	Link Here

Lines 1-10	Link Here

// Clearing a Set after deleting some entries works.

// Clearing a Set after deleting some entries works.

var s = Set(["a", "b", "c", "d"]);

var s = new Set(["a", "b", "c", "d"]);

for (var v of s)

for (var v of s)

    if (v !== "c")

    if (v !== "c")

        s.delete(v);

        s.delete(v);

s.clear();

s.clear();

assertEq(s.size, 0);

assertEq(s.size, 0);

assertEq(s.has("c"), false);

assertEq(s.has("c"), false);

assertEq(s.has("d"), false);

assertEq(s.has("d"), false);

(-)a/js/src/jit-test/tests/collections/Set-clear-5.js (-1 / +1 lines)

Line	Link Here

Lines 1-12	Link Here

// Set.clear is unaffected by deleting/monkeypatching Set.prototype.{delete,iterator}.

// Set.clear is unaffected by deleting/monkeypatching Set.prototype.{delete,iterator}.

var data = ["a", 1, {}];

var data = ["a", 1, {}];

var s1 = Set(data), s2 = Set(data);

var s1 = new Set(data), s2 = new Set(data);

delete Set.prototype.delete;

delete Set.prototype.delete;

delete Set.prototype.iterator;

delete Set.prototype.iterator;

s1.clear();

s1.clear();

assertEq(s1.size, 0);

assertEq(s1.size, 0);

Set.prototype.delete = function () { throw "FAIL"; };

Set.prototype.delete = function () { throw "FAIL"; };

Set.prototype.iterator = function () { throw "FAIL"; };

Set.prototype.iterator = function () { throw "FAIL"; };

(-)a/js/src/jit-test/tests/collections/Set-clear-6.js (-1 / +1 lines)

Line	Link Here

Lines 1-6	Link Here

// Clearing a Set doesn't affect expando properties.

// Clearing a Set doesn't affect expando properties.

var s = Set();

var s = new Set();

s.x = 3;

s.x = 3;

s.clear();

s.clear();

assertEq(s.x, 3);

assertEq(s.x, 3);

(-)a/js/src/jit-test/tests/collections/Set-clear-gc.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Clearing a Set removes any strong references to its elements.

// Clearing a Set removes any strong references to its elements.

load(libdir + "referencesVia.js");

load(libdir + "referencesVia.js");

var s = Set();

var s = new Set();

var obj = {};

var obj = {};

s.add(obj);

s.add(obj);

assertEq(referencesVia(s, "key", obj), true);

assertEq(referencesVia(s, "key", obj), true);

s.clear();

s.clear();

if (typeof findReferences == 'function')

if (typeof findReferences == 'function')

    assertEq(referencesVia(s, "key", obj), false);

    assertEq(referencesVia(s, "key", obj), false);





// A Set iterator does not visit entries removed by clear().

load(libdir + "iteration.js");

var s = new Set();
var it = s[Symbol.iterator]();
s.clear();
assertIteratorDone(it, undefined);

s = new Set(["a", "b", "c", "d"]);
it = s[Symbol.iterator]();
assertIteratorNext(it, "a");
s.clear();
assertIteratorDone(it, undefined);

var log = "";
s = new Set(["a", "b", "c", "d"]);
for (var v of s) {
    log += v;
    if (v == "b")
        s.clear();
}
assertEq(log, "ab");

(-)a/js/src/jit-test/tests/collections/Set-clear-iterators-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// A Set iterator continues to visit entries added after a clear().

// A Set iterator continues to visit entries added after a clear().

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var s = Set(["a"]);

var s = new Set(["a"]);

var it = s[Symbol.iterator]();

var it = s[Symbol.iterator]();

assertIteratorNext(it, "a");

assertIteratorNext(it, "a");

s.clear();

s.clear();

s.add("b");

s.add("b");

assertIteratorNext(it, "b");

assertIteratorNext(it, "b");

assertIteratorDone(it, undefined);

assertIteratorDone(it, undefined);

(-)a/js/src/jit-test/tests/collections/Set-clear-iterators-3.js (-1 / +1 lines)

Line	Link Here

Lines 1-10	Link Here

// A closed Set iterator does not visit new entries added after a clear().

// A closed Set iterator does not visit new entries added after a clear().

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var s = Set();

var s = new Set();

var it = s[Symbol.iterator]();

var it = s[Symbol.iterator]();

assertIteratorDone(it, undefined);  // close the iterator

assertIteratorDone(it, undefined);  // close the iterator

s.clear();

s.clear();

s.add("a");

s.add("a");

assertIteratorDone(it, undefined);

assertIteratorDone(it, undefined);

(-)a/js/src/jit-test/tests/collections/Set-constructor-1.js (-3 / +1 lines)

Line	Link Here

Lines 1-7	Link Here

// The Set constructor creates an empty Set by default.

// The Set constructor creates an empty Set by default.

assertEq(Set().size, 0);

assertEq(new Set().size, 0);

assertEq((new Set).size, 0);

assertEq(Set(undefined).size, 0);

assertEq(new Set(undefined).size, 0);

assertEq(new Set(undefined).size, 0);

assertEq(new Set(null).size, 0);

assertEq(new Set(null).size, 0);





// The Set constructor can take an argument that is an array.

var s = new Set([]);
assertEq(s.size, 0);
assertEq(s.has(undefined), false);

s = new Set(["one", "two", "three"]);
assertEq(s.size, 3);
assertEq(s.has("one"), true);
assertEq(s.has("eleventeen"), false);

var a = [{}, {}, {}];
s = new Set(a);
assertEq(s.size, 3);
for (let obj of a)
    assertEq(s.has(obj), true);
assertEq(s.has({}), false);
assertEq(s.has("three"), false);

(-)a/js/src/jit-test/tests/collections/Set-constructor-3.js (-2 / +2 lines)

Line	Link Here

Lines 1-11	Link Here

// The argument to Set may contain a value multiple times. Duplicates are discarded.

// The argument to Set may contain a value multiple times. Duplicates are discarded.

assertEq(Set(["testing", "testing", 123]).size, 2);

assertEq(new Set(["testing", "testing", 123]).size, 2);

var values = [undefined, null, false, NaN, 0, -0, 6.022e23, -Infinity, "", "xyzzy", {}, Math.sin];

var values = [undefined, null, false, NaN, 0, -0, 6.022e23, -Infinity, "", "xyzzy", {}, Math.sin];

for (let v of values) {

for (let v of values) {

    var a = [v, {}, {}, {}, v, {}, v, v];

    var a = [v, {}, {}, {}, v, {}, v, v];

    var s = Set(a);

    var s = new Set(a);

    assertEq(s.size, 5);

    assertEq(s.size, 5);

    assertEq(s.has(v), true);

    assertEq(s.has(v), true);

(-)a/js/src/jit-test/tests/collections/Set-constructor-generator-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-12	Link Here

// The argument to Set can be a generator.

// The argument to Set can be a generator.

function hexData(n) {

function hexData(n) {

    for (var i = 0; i < n; i++)

    for (var i = 0; i < n; i++)

        yield i.toString(16);

        yield i.toString(16);

var s = Set(hexData(256));

var s = new Set(hexData(256));

assertEq(s.size, 256);

assertEq(s.size, 256);

assertEq(s.has("0"), true);

assertEq(s.has("0"), true);

assertEq(s.has(0), false);

assertEq(s.has(0), false);

assertEq(s.has("ff"), true);

assertEq(s.has("ff"), true);

(-)a/js/src/jit-test/tests/collections/Set-constructor-generator-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

// The argument to Set can be a generator-expression.

// The argument to Set can be a generator-expression.

var s = Set(k * k for (k of [1, 2, 3, 4]));

var s = new Set(k * k for (k of [1, 2, 3, 4]));

assertEq(s.size, 4);

assertEq(s.size, 4);

assertEq(s.has(1), true);

assertEq(s.has(1), true);

assertEq(s.has(4), true);

assertEq(s.has(4), true);

assertEq(s.has(9), true);

assertEq(s.has(9), true);

assertEq(s.has(16), true);

assertEq(s.has(16), true);

(-)a/js/src/jit-test/tests/collections/Set-delete-size.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// set.delete(v) decrements set.size iff the set contained v.

// set.delete(v) decrements set.size iff the set contained v.

var s = Set();

var s = new Set();

for (var i = 0; i < 10; i++)

for (var i = 0; i < 10; i++)

    s.add(i);

    s.add(i);

for (var i = 10; i > 0; i--) {

for (var i = 10; i > 0; i--) {

    assertEq(s.size, i);

    assertEq(s.size, i);

    assertEq(s.delete(i), false);

    assertEq(s.delete(i), false);

    assertEq(s.size, i);

    assertEq(s.size, i);

    assertEq(s.delete(i - 1), true);

    assertEq(s.delete(i - 1), true);

(-)a/js/src/jit-test/tests/collections/Set-iterator-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// for-of can be used to iterate over a Set twice.

// for-of can be used to iterate over a Set twice.

var set = Set(['a', 'b', 'c']);

var set = new Set(['a', 'b', 'c']);

var log = '';

var log = '';

for (let i = 0; i < 2; i++) {

for (let i = 0; i < 2; i++) {

    for (let x of set)

    for (let x of set)

        log += x;

        log += x;

    log += ';'

    log += ';'

assertEq(log, 'abc;abc;');

assertEq(log, 'abc;abc;');

(-)a/js/src/jit-test/tests/collections/Set-iterator-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Nested for-of loops can iterate over a Set.

// Nested for-of loops can iterate over a Set.

var map = Set(['a', 'b']);

var map = new Set(['a', 'b']);

var log = '';

var log = '';

for (let x of map) {

for (let x of map) {

    log += x + ':'

    log += x + ':'

    for (let y of map)

    for (let y of map)

        log += y;

        log += y;

    log += ';'

    log += ';'

};

};

assertEq(log, 'a:ab;b:ab;');

assertEq(log, 'a:ab;b:ab;');

(-)a/js/src/jit-test/tests/collections/Set-iterator-3.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Iterating over a set of objects yields those exact objects.

// Iterating over a set of objects yields those exact objects.

var arr = [{}, {}, {}, [], /xyz/, new Date];

var arr = [{}, {}, {}, [], /xyz/, new Date];

var set = Set(arr);

var set = new Set(arr);

assertEq(set.size, arr.length);

assertEq(set.size, arr.length);

var i = 0;

var i = 0;

for (var x of set)

for (var x of set)

    assertEq(x, arr[i++]);

    assertEq(x, arr[i++]);

assertEq(i, arr.length);

assertEq(i, arr.length);

(-)a/js/src/jit-test/tests/collections/Set-iterator-add-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// set.iterator() is live: entries added during iteration are visited.

// set.iterator() is live: entries added during iteration are visited.

var set = Set([5]);

var set = new Set([5]);

var log = '';

var log = '';

for (let x of set) {

for (let x of set) {

    log += x + ';';

    log += x + ';';

    if (x > 0)

    if (x > 0)

        set.add(x - 1);

        set.add(x - 1);

assertEq(log, '5;4;3;2;1;0;');

assertEq(log, '5;4;3;2;1;0;');

assertEq(set.size, 6);

assertEq(set.size, 6);

(-)a/js/src/jit-test/tests/collections/Set-iterator-add-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-10	Link Here

// A Set iterator does not iterate over new entries added after it throws StopIteration.

// A Set iterator does not iterate over new entries added after it throws StopIteration.

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var set = Set();

var set = new Set();

var iter0 = set[Symbol.iterator](), iter1 = set[Symbol.iterator]();

var iter0 = set[Symbol.iterator](), iter1 = set[Symbol.iterator]();

assertIteratorDone(iter0, undefined);  // closes iter0

assertIteratorDone(iter0, undefined);  // closes iter0

set.add("x");

set.add("x");

assertIteratorDone(iter0, undefined);  // already closed

assertIteratorDone(iter0, undefined);  // already closed

assertIteratorNext(iter1, "x");  // was not yet closed

assertIteratorNext(iter1, "x");  // was not yet closed

(-)a/js/src/jit-test/tests/collections/Set-iterator-add-remove.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Removing and re-adding entries while an iterator is live causes the iterator to visit them again.

// Removing and re-adding entries while an iterator is live causes the iterator to visit them again.

var set = Set(['a']);

var set = new Set(['a']);

var n = 5;

var n = 5;

for (let v of set) {

for (let v of set) {

    assertEq(v, 'a');

    assertEq(v, 'a');

    if (n === 0)

    if (n === 0)

        break;

        break;

    set.delete('a');

    set.delete('a');

    set.add('a');

    set.add('a');

    n--;

    n--;

(-)a/js/src/jit-test/tests/collections/Set-iterator-gc-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-10	Link Here

// A Set iterator keeps the data alive.

// A Set iterator keeps the data alive.

load(libdir + "referencesVia.js");

load(libdir + "referencesVia.js");

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var key = {};

var key = {};

var set = Set([key]);

var set = new Set([key]);

var iter = set[Symbol.iterator]();

var iter = set[Symbol.iterator]();

referencesVia(iter, "**UNKNOWN SLOT 0**", set);

referencesVia(iter, "**UNKNOWN SLOT 0**", set);

referencesVia(set, "key", key);

referencesVia(set, "key", key);

(-)a/js/src/jit-test/tests/collections/Set-iterator-gc-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

// GC-ing during a for-of loop doesn't crash.

// GC-ing during a for-of loop doesn't crash.

var i = 0;

var i = 0;

for (var x of Set(Object.getOwnPropertyNames(this))) {

for (var x of new Set(Object.getOwnPropertyNames(this))) {

    gc();

    gc();

    if (++i >= 20)

    if (++i >= 20)

        break;

        break;

(-)a/js/src/jit-test/tests/collections/Set-iterator-gc-3.js (-16 / +16 lines)

Line	Link Here

Lines 1-20	Link Here

// GC in nested for-loops is safe.

// GC in nested for-loops is safe.

var x;

var x;

for (x of Set([1]))

for (x of new Set([1]))

    for (x of Set([1]))

    for (x of new Set([1]))

        for (x of Set([1]))

        for (x of new Set([1]))

            for (x of Set([1]))

            for (x of new Set([1]))

                for (x of Set([1]))

                for (x of new Set([1]))

                    for (x of Set([1]))

                    for (x of new Set([1]))

                        for (x of Set([1]))

                        for (x of new Set([1]))

                            for (x of Set([1]))

                            for (x of new Set([1]))

                                for (x of Set([1]))

                                for (x of new Set([1]))

                                    for (x of Set([1]))

                                    for (x of new Set([1]))

                                        for (x of Set([1]))

                                        for (x of new Set([1]))

                                            for (x of Set([1]))

                                            for (x of new Set([1]))

                                                for (x of Set([1]))

                                                for (x of new Set([1]))

                                                    for (x of Set([1]))

                                                    for (x of new Set([1]))

                                                        for (x of Set([1]))

                                                        for (x of new Set([1]))

                                                            for (x of Set([1]))

                                                            for (x of new Set([1]))

                                                                gc();

                                                                gc();

(-)a/js/src/jit-test/tests/collections/Set-iterator-order.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// Set iterators produces entries in the order they were inserted.

// Set iterators produces entries in the order they were inserted.

var set = Set();

var set = new Set();

var i;

var i;

for (i = 7; i !== 1; i = i * 7 % 1117)

for (i = 7; i !== 1; i = i * 7 % 1117)

    set.add(i);

    set.add(i);

assertEq(set.size, 557);

assertEq(set.size, 557);

i = 7;

i = 7;

for (var v of set) {

for (var v of set) {

    assertEq(v, i);

    assertEq(v, i);

(-)a/js/src/jit-test/tests/collections/Set-iterator-proxies-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

// for-of works on a cross-compartment wrapper of a Set.

// for-of works on a cross-compartment wrapper of a Set.

var g = newGlobal();

var g = newGlobal();

var mw = g.eval("Set(['a', 'b', 1, 2])");

var mw = g.eval("new Set(['a', 'b', 1, 2])");

var log = '';

var log = '';

for (let x of mw)

for (let x of mw)

    log += x;

    log += x;

assertEq(log, "ab12");

assertEq(log, "ab12");





load(libdir + "asserts.js");
load(libdir + "iteration.js");

var g = newGlobal();

var iterator_fn = Set.prototype[Symbol.iterator];
assertThrowsInstanceOf(function () { iterator_fn.call({}); }, TypeError);
assertThrowsInstanceOf(function () { iterator_fn.call(new Map()); }, TypeError);
var setw = g.eval("new Set(['x', 'y'])");
assertIteratorNext(iterator_fn.call(setw), "x");

var next_fn = new Set()[Symbol.iterator]().next;
assertThrowsInstanceOf(function () { next_fn.call({}); }, TypeError);
assertThrowsInstanceOf(function () { next_fn.call(new Map()[Symbol.iterator]()); }, TypeError);
var iterw = setw[Symbol.iterator]();
assertIteratorResult(next_fn.call(iterw), "x", false);
assertIteratorResult(next_fn.call(iterw), "y", false);
assertIteratorResult(next_fn.call(iterw), undefined, true);

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-1.js (-2 / +2 lines)

Line	Link Here

Lines 1-13	Link Here

// A set iterator can cope with removing the current entry.

// A set iterator can cope with removing the current entry.

function test(letters, toRemove) {

function test(letters, toRemove) {

    var set = Set(letters);

    var set = new Set(letters);

    toRemove = Set(toRemove);

    toRemove = new Set(toRemove);

    var leftovers = [x for (x of set) if (!toRemove.has(x))].join("");

    var leftovers = [x for (x of set) if (!toRemove.has(x))].join("");

    var log = "";

    var log = "";

    for (let x of set) {

    for (let x of set) {

        log += x;

        log += x;

        if (toRemove.has(x))

        if (toRemove.has(x))

            set.delete(x);

            set.delete(x);

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-13	Link Here

// A map iterator can cope with removing the next entry.

// A map iterator can cope with removing the next entry.

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var set = Set("abcd");

var set = new Set("abcd");

var iter = set[Symbol.iterator]();

var iter = set[Symbol.iterator]();

var log = "";

var log = "";

for (let x of iter) {

for (let x of iter) {

    log += x;

    log += x;

    if (x === "b")

    if (x === "b")

        set.delete("c");

        set.delete("c");

assertEq(log, "abd");

assertEq(log, "abd");

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-3.js (-1 / +1 lines)

Line	Link Here

Lines 1-12	Link Here

// A set iterator can cope with removing the next entry, then the current entry.

// A set iterator can cope with removing the next entry, then the current entry.

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var set = Set("abcd");

var set = new Set("abcd");

var iter = set[Symbol.iterator]();

var iter = set[Symbol.iterator]();

assertIteratorNext(iter, "a");

assertIteratorNext(iter, "a");

assertIteratorNext(iter, "b");

assertIteratorNext(iter, "b");

set.delete("c");

set.delete("c");

set.delete("b");

set.delete("b");

assertIteratorNext(iter, "d");

assertIteratorNext(iter, "d");

assertIteratorDone(iter, undefined);

assertIteratorDone(iter, undefined);

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-4.js (-1 / +1 lines)

Line	Link Here

Lines 1-14	Link Here

// Multiple live iterators on the same Set can cope with removing entries.

// Multiple live iterators on the same Set can cope with removing entries.

load(libdir + "iteration.js");

load(libdir + "iteration.js");

// Make a set.

// Make a set.

var set = Set();

var set = new Set();

var SIZE = 7;

var SIZE = 7;

for (var j = 0; j < SIZE; j++)

for (var j = 0; j < SIZE; j++)

    set.add(j);

    set.add(j);

// Make lots of iterators pointing to entry 2 of the set.

// Make lots of iterators pointing to entry 2 of the set.

var NITERS = 5;

var NITERS = 5;

var iters = [];

var iters = [];

for (var i = 0; i < NITERS; i++) {

for (var i = 0; i < NITERS; i++) {

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-5.js (-1 / +1 lines)

Line	Link Here

Lines 1-13	Link Here

// Removing a Set entry already visited by an iterator does not cause any

// Removing a Set entry already visited by an iterator does not cause any

// entries to be skipped.

// entries to be skipped.

var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

var set = Set(str);

var set = new Set(str);

var log = '';

var log = '';

var i = 0;

var i = 0;

for (var x of set) {

for (var x of set) {

    log += x;

    log += x;

    if (i++ % 5 === 0) {

    if (i++ % 5 === 0) {

        // Delete all entries preceding this one.

        // Delete all entries preceding this one.

        for (let y of set) {

        for (let y of set) {

(-)a/js/src/jit-test/tests/collections/Set-iterator-remove-6.js (-1 / +1 lines)

Line	Link Here

Lines 1-15	Link Here

// Removing many Set entries does not cause a live iterator to skip any of the

// Removing many Set entries does not cause a live iterator to skip any of the

// entries that were not removed. (Compacting a Set must not be observable to

// entries that were not removed. (Compacting a Set must not be observable to

// script.)

// script.)

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var set = Set();

var set = new Set();

for (var i = 0; i < 32; i++)

for (var i = 0; i < 32; i++)

    set.add(i);

    set.add(i);

var iter = set[Symbol.iterator]();

var iter = set[Symbol.iterator]();

assertIteratorNext(iter, 0);

assertIteratorNext(iter, 0);

for (var i = 0; i < 30; i++)

for (var i = 0; i < 30; i++)

    set.delete(i);

    set.delete(i);

assertEq(set.size, 2);

assertEq(set.size, 2);

for (var i = 32; i < 100; i++)

for (var i = 32; i < 100; i++)

(-)a/js/src/jit-test/tests/collections/Set-size.js (-1 / +1 lines)

Line	Link Here

Lines 1-7	Link Here

// Each Set has its own size.

// Each Set has its own size.

var s1 = Set(), s2 = Set();

var s1 = new Set(), s2 = new Set();

for (var i = 0; i < 30; i++)

for (var i = 0; i < 30; i++)

    s1.add(i);

    s1.add(i);

assertEq(s1.size, 30);

assertEq(s1.size, 30);

assertEq(s2.size, 0);

assertEq(s2.size, 0);






assertEq(typeof Set, 'function');
assertEq(Object.keys(Set).length, 0);
assertEq(Set.length, 1);
assertEq(Set.name, "Set");

assertEq(Object.getPrototypeOf(Set.prototype), Object.prototype);
assertEq(Object.prototype.toString.call(Set.prototype), "[object Set]");
assertEq(Object.prototype.toString.call(new Set()), "[object Set]");
assertEq(Object.prototype.toString.call(Set()), "[object Set]");
assertEq(Object.keys(Set.prototype).join(), "");
assertEq(Set.prototype.constructor, Set);

function checkMethod(name, arity) { 
    var desc = Object.getOwnPropertyDescriptor(Set.prototype, name);
    assertEq(desc.enumerable, false);
    assertEq(desc.configurable, true);
    assertEq(desc.writable, true);

(-)a/js/src/jit-test/tests/collections/Set-values-1.js (-1 / +1 lines)

Line	Link Here

Lines 1-11	Link Here

// set.keys(), .values(), and .entries() on an empty set produce empty iterators

// set.keys(), .values(), and .entries() on an empty set produce empty iterators

var s = Set();

var s = new Set();

var ki = s.keys(), vi = s.values(), ei = s.entries();

var ki = s.keys(), vi = s.values(), ei = s.entries();

var p = Object.getPrototypeOf(ki);

var p = Object.getPrototypeOf(ki);

assertEq(Object.getPrototypeOf(vi), p);

assertEq(Object.getPrototypeOf(vi), p);

assertEq(Object.getPrototypeOf(ei), p);

assertEq(Object.getPrototypeOf(ei), p);

for (let k of ki)

for (let k of ki)

	throw "FAIL";

	throw "FAIL";

for (let v of vi)

for (let v of vi)

(-)a/js/src/jit-test/tests/collections/Set-values-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-15	Link Here

// set.keys() and set.values() return iterators over the elements

// set.keys() and set.values() return iterators over the elements

// and set.entries() returns an iterator that yields pairs [e, e].

// and set.entries() returns an iterator that yields pairs [e, e].

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var data = [1, 2, 3, 4];

var data = [1, 2, 3, 4];

var s = Set(data);

var s = new Set(data);

var ki = s.keys();

var ki = s.keys();

assertIteratorNext(ki, 1);

assertIteratorNext(ki, 1);

assertIteratorNext(ki, 2);

assertIteratorNext(ki, 2);

assertIteratorNext(ki, 3);

assertIteratorNext(ki, 3);

assertIteratorNext(ki, 4);

assertIteratorNext(ki, 4);

assertIteratorDone(ki, undefined);

assertIteratorDone(ki, undefined);

(-)a/js/src/jit-test/tests/collections/WeakSet-constructor.js (-1 / +1 lines)

Line	Link Here

Lines 1-9	Link Here

var list = [Number, Function];

var list = [Number, Function];

var ws = new WeakSet(list);

var ws = new WeakSet(list);

assertEq(ws.has(Number), true);

assertEq(ws.has(Number), true);

assertEq(ws.has(Function), true);

assertEq(ws.has(Function), true);

ws = new WeakSet(Set(list));

ws = new WeakSet(new Set(list));

assertEq(ws.has(Number), true);

assertEq(ws.has(Number), true);

assertEq(ws.has(Function), true);

assertEq(ws.has(Function), true);

(-)a/js/src/jit-test/tests/collections/constructor-errors.js (-1 / +1 lines)

Line	Link Here

Lines 12-22 var misc = [	Link Here

    new Boolean(true), new Number(0),

    new Boolean(true), new Number(0),

    {iterator: function () { return undefined; }},

    {iterator: function () { return undefined; }},

    {iterator: function () { return null; }},

    {iterator: function () { return null; }},

    {iterator: function () { return true; }},

    {iterator: function () { return true; }},

    {iterator: function () { return 17; }},

    {iterator: function () { return 17; }},

];

];

for (var v of misc) {

for (var v of misc) {

    assertThrowsInstanceOf(function () { Set(v); }, TypeError);

    assertThrowsInstanceOf(function () { new Set(v); }, TypeError);

    assertThrowsInstanceOf(function () { new Map(v); }, TypeError);

    assertThrowsInstanceOf(function () { new Map(v); }, TypeError);

(-)a/js/src/jit-test/tests/collections/iterator-gc.js (-1 / +1 lines)

Line	Link Here

Lines 8-16 var key = {};	Link Here

function test(obj, edgeName) {

function test(obj, edgeName) {

    var iter = obj[Symbol.iterator]();

    var iter = obj[Symbol.iterator]();

    referencesVia(iter, "**UNKNOWN SLOT 0**", obj);

    referencesVia(iter, "**UNKNOWN SLOT 0**", obj);

    referencesVia(obj, edgeName, key);

    referencesVia(obj, edgeName, key);

test([key],                     "element[0]");

test([key],                     "element[0]");

test(new Map([[key, 'value']]), "key");

test(new Map([[key, 'value']]), "key");

test(Set([key]),                "key");

test(new Set([key]),            "key");

(-)a/js/src/jit-test/tests/collections/iterator-proto-1.js (-1 / +1 lines)

Line	Link Here

Lines 7-15 function test(obj0, obj1) {	Link Here

    var iter0 = obj0[Symbol.iterator](), iter1 = obj1[Symbol.iterator]();

    var iter0 = obj0[Symbol.iterator](), iter1 = obj1[Symbol.iterator]();

    var proto = Object.getPrototypeOf(iter0);

    var proto = Object.getPrototypeOf(iter0);

    assertEq(Object.getPrototypeOf(iter1), proto);

    assertEq(Object.getPrototypeOf(iter1), proto);

    assertEq(Object.getPrototypeOf(proto), Iterator.prototype);

    assertEq(Object.getPrototypeOf(proto), Iterator.prototype);

test([], [1]);

test([], [1]);

test(new Map(), new Map([[1, 1]]));

test(new Map(), new Map([[1, 1]]));

test(Set(), Set([1]));

test(new Set(), new Set([1]));

(-)a/js/src/jit-test/tests/collections/iterator-proto-2.js (-1 / +1 lines)

Line	Link Here

Lines 1-13	Link Here

// Iterators of different collection types have different prototypes.

// Iterators of different collection types have different prototypes.

load(libdir + "iteration.js");

load(libdir + "iteration.js");

var aproto = Object.getPrototypeOf(Array()[Symbol.iterator]());

var aproto = Object.getPrototypeOf(Array()[Symbol.iterator]());

var mproto = Object.getPrototypeOf(new Map()[Symbol.iterator]());

var mproto = Object.getPrototypeOf(new Map()[Symbol.iterator]());

var sproto = Object.getPrototypeOf(Set()[Symbol.iterator]());

var sproto = Object.getPrototypeOf(new Set()[Symbol.iterator]());

assertEq(aproto !== mproto, true);

assertEq(aproto !== mproto, true);

assertEq(aproto !== sproto, true);

assertEq(aproto !== sproto, true);

assertEq(mproto !== sproto, true);

assertEq(mproto !== sproto, true);

assertEq(aproto.next !== mproto.next, true);

assertEq(aproto.next !== mproto.next, true);

assertEq(aproto.next !== sproto.next, true);

assertEq(aproto.next !== sproto.next, true);

assertEq(mproto.next !== sproto.next, true);

assertEq(mproto.next !== sproto.next, true);





lfcode.push("{ function foo() {} }");
lfcode.push("evaluate('\
var INVALIDATE_MODES = INVALIDATE_MODE_STRINGS.map(s => ({mode: s}));\
function range(n, m) {}\
function seq_scan(array, f) {}\
function assertStructuralEq(e1, e2) {}\
for (var i = 0, l = a.length; i < l; i++) {}\
');");
lfcode.push("for (var x of new Set(Object.getOwnPropertyNames(this))) {}");
var lfRunTypeId = -1;
while (true) {
  var file = lfcode.shift(); if (file == undefined) { break; }
  loadFile(file)
}
function loadFile(lfVarx) {
    try {
        if (lfVarx.substr(-3) == ".js") {}

(-)a/js/src/jit-test/tests/generators/bug908920.js (-1 / +1 lines)

Line	Link Here

Lines 1-9	Link Here

if (typeof schedulegc != 'undefined') {

if (typeof schedulegc != 'undefined') {

    Function("\

    Function("\

        x = (function() { yield })();\

        x = (function() { yield })();\

        Set(x);\

        new Set(x);\

        schedulegc(1);\

        schedulegc(1);\

        print( /x/ );\

        print( /x/ );\

        for (p in x) {}\

        for (p in x) {}\

    ")();

    ")();

(-)a/js/src/jit-test/tests/structured-clone/Map-Set-cross-compartment.js (-1 / +1 lines)

Line	Link Here

Lines 1-8	Link Here

/*

/*

 * Any copyright is dedicated to the Public Domain.

 * Any copyright is dedicated to the Public Domain.

 * http://creativecommons.org/licenses/publicdomain/

 * http://creativecommons.org/licenses/publicdomain/

*/

*/

// Don't crash

// Don't crash

serialize(evalcx("Set(['x', 'y'])"));

serialize(evalcx("new Set(['x', 'y'])"));

serialize(evalcx("new Map([['x', 1]])"));

serialize(evalcx("new Map([['x', 1]])"));

Return to bug 1108930