Merge pull request #61 from oven-sh/upgrade

Sync with upstream

JSTests/microbenchmarks/double-to-string.js

@@ -0,0 +1,7 @@
+function test(num) {
+    return num + 'px';
+}
+noInline(test);
+
+for (var i = 0; i < 1e6; ++i)
+    test(i + 30.4);

JSTests/microbenchmarks/js-map-get-int-no-dfg-no-inline.js

@@ -0,0 +1,24 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+noDFG(testSet);
+noInline(testSet);
+
+function testGet(m, k) {
+    m.get(k);
+}
+noDFG(testGet);
+noInline(testGet);
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    testSet(m, i, i);
+}
+
+for (let i = 0; i < count; ++i) {
+    for (let j = 0; j < 20; j++) {
+        testGet(m, i, i);
+    }
+}

JSTests/microbenchmarks/js-map-get-int.js

@@ -0,0 +1,21 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+
+function testGet(m, k) {
+    m.get(k);
+}
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    testSet(m, i, i);
+}
+
+for (let i = 0; i < count; ++i) {
+    for (let j = 0; j < 20; j++) {
+        testGet(m, i, i);
+    }
+}
+

JSTests/microbenchmarks/js-map-get-string-no-dfg-no-inline.js

@@ -0,0 +1,27 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+noDFG(testSet);
+noInline(testSet);
+
+function testGet(m, k) {
+    m.get(k);
+}
+noDFG(testGet);
+noInline(testGet);
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    testSet(m, s, s);
+}
+
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    for (let j = 0; j < 20; j++) {
+        testGet(m, s);
+    }
+}
+

JSTests/microbenchmarks/js-map-get-string.js

@@ -0,0 +1,22 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+
+function testGet(m, k) {
+    m.get(k);
+}
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    testSet(m, s, s);
+}
+
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    for (let j = 0; j < 20; j++) {
+        testGet(m, s);
+    }
+}

JSTests/microbenchmarks/js-map-set-int-no-dfg-no-inline.js

@@ -0,0 +1,12 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+noDFG(testSet);
+noInline(testSet);
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    testSet(m, i, i);
+}

JSTests/microbenchmarks/js-map-set-int.js

@@ -0,0 +1,10 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    testSet(m, i, i);
+}

JSTests/microbenchmarks/js-map-set-string-no-dfg-no-inline.js

@@ -0,0 +1,13 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+noDFG(testSet);
+noInline(testSet);
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    testSet(m, s, s);
+}

JSTests/microbenchmarks/js-map-set-string.js

@@ -0,0 +1,11 @@
+let m = new Map();
+
+function testSet(m, k, v) {
+    m.set(k, v);
+}
+
+let count = 1e4;
+for (let i = 0; i < count; ++i) {
+    let s = i.toString();
+    testSet(m, s, s);
+}

JSTests/microbenchmarks/to-hex.js

@@ -0,0 +1,14 @@
+//@ requireOptions("--useUint8ArrayBase64Methods=1")
+
+function test(buffer)
+{
+    return buffer.toHex();
+}
+noInline(test);
+
+let buffer = new Uint8Array(16 * 1024);
+for (let i = 0; i < buffer.length; ++i)
+    buffer[i] = i & 0xff;
+
+for (let i = 0; i < 1e4; ++i)
+    test(buffer);

JSTests/stress/double-to-string.js

@@ -0,0 +1,12 @@
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error('bad value: ' + actual);
+}
+
+function test(num) {
+    return num + 'px';
+}
+noInline(test);
+
+for (var i = 0; i < 1e6; ++i)
+    shouldBe(test(i + 30.4), (i + 30.4) + 'px');

JSTests/stress/map-iterators-next-2.js

@@ -0,0 +1,110 @@
+function assert(b) {
+    if (!b)
+        throw new Error("Bad result!");
+}
+noInline(assert);
+
+let item1 = [1, 2];
+let item2 = [3, 4];
+
+{
+    let map = new Map();
+    let iterator = map[Symbol.iterator]();
+    map.set(item1[0], item1[1]);
+    let element = iterator.next();
+
+    assert(element.done == false);
+    assert(element.value[0] == item1[0]);
+}
+
+{
+    let map = new Map([item1]);
+    let iterator = map[Symbol.iterator]();
+    map.set(item2[0], item2[1]);
+    let element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item1[0]);
+
+    element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item2[0]);
+}
+
+{
+    let map = new Map([item1]);
+    let iterator = map[Symbol.iterator]();
+    map.delete(item1[0]);
+
+    let element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+}
+
+{
+    let map = new Map([item1, item2]);
+    let iterator = map[Symbol.iterator]();
+    map.delete(item2[0]);
+
+    let element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item1[0]);
+
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+}
+
+{
+    let map = new Map([item1, item2]);
+    let iterator = map[Symbol.iterator]();
+
+    let element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item1[0]);
+
+    element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item2[0]);
+
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+}
+
+{
+    let map = new Map([item1]);
+    let iterator = map[Symbol.iterator]();
+    map.clear();
+
+    let element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+
+    map.set(item1[0], item1[1]);
+    element = iterator.next();
+    assert(element.done == true);
+    assert(element.value == undefined);
+}
+
+{
+    let map = new Map([item1]);
+    let iterator = map[Symbol.iterator]();
+    map.clear();
+
+    map.set(item1[0], item1[1]);
+    element = iterator.next();
+    assert(element.done == false);
+    assert(element.value[0] == item1[0]);
+}