[async-iteration] add support for for-await-of loops in Async Functions

test/mjsunit/harmony/for-await-of.js

Index: test/mjsunit/harmony/for-await-of.js
diff --git a/test/mjsunit/harmony/for-await-of.js b/test/mjsunit/harmony/for-await-of.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a351f37692afbfd7ddb577aa743df5e57f0c4f9
--- /dev/null
+++ b/test/mjsunit/harmony/for-await-of.js
@@ -0,0 +1,528 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --harmony-async-iteration --allow-natives-syntax --no-lazy

[neis, 2017/01/20 14:38:16]

Why do you require --no-lazy?

[caitp, 2017/01/20 20:17:19]

This was from debugging the issue with lexical variables (there's a syntax error
on the first test which uses a lexical declaration in the loop head, because the
desugaring tries to declare it twice for some reason).

The --no-lazy will disappear, but it does for the time being make it easier to
debug that problem. Need parser experts to help figure that out

+
+let testFailed = false;
+let testFailure;
+(async function() {
+
+  function async(iterable) {
+    // Helper to turn a synchronous iterable into an asynchronous iterable,
+    // without using the [Async-from-Sync Iterator].
+    let it = iterable[Symbol.iterator]();
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+      ,
+
+          next() {

[neis, 2017/01/20 14:38:16]

The formatting here seems odd.

[caitp, 2017/01/20 20:17:19]

I think clang-format doesn't really know how to deal with modern JavaScript.
I'll manually format these later I guess.

+        return new Promise(function(resolve, reject) {
+          let {value, done} = it.next();
+          Promise.resolve(value).then(function(value) {
+            resolve({value, done});
+          }, reject);
+        });
+      }
+    }
+  }
+
+  let testDone;
+  let test;

[neis, 2017/01/20 14:38:16]

nit: add blank line

[caitp, 2017/01/20 20:17:19]

Done.

+  async function testBindingIdentifierVarDeclarationStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(var value of async([100, 200, 300, 400, 500])) sum += value;
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierVarDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testBindingIdentifierVarDeclarationBlockStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(var value of async([100, 200, 300, 400, 500])) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        sum += value;
+      }
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierVarDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternVarDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(var {key = 'unknown', value} of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternVarDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternVarDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(var {key = 'unknown', value} of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternVarDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternVarDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(var [key = 'unknown', value] of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternVarDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternVarDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(var [key = 'unknown', value] of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternVarDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  // --------------------------------------------------------------------------
+
+  async function testBindingIdentifierLetDeclarationStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(let value of async([100, 200, 300, 400, 500])) sum += value;
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierLetDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testBindingIdentifierLetDeclarationBlockStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(let value of async([100, 200, 300, 400, 500])) {
+        'use strict';
+        // Ensure strict mode applies to block with use-strict-directive

[neis, 2017/01/20 14:38:16]

Do you mean "does not apply"?

Maybe replace the comment and body with

let strict = (function() { return this === undefined; })();
assertFalse(strict);

(Also in similar tests above.)

[caitp, 2017/01/20 20:17:19]

sgtm, done

+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        sum += value;
+      }
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierLetDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternLetDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(let {key = 'unknown', value} of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternLetDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternLetDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(let {key = 'unknown', value} of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternLetDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternLetDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(let [key = 'unknown', value] of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternLetDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternLetDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(let [key = 'unknown', value] of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternLetDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  // --------------------------------------------------------------------------
+
+  async function testBindingIdentifierConstDeclarationStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(let value of async([100, 200, 300, 400, 500])) sum += value;
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierConstDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testBindingIdentifierConstDeclarationBlockStatement() {
+    let sum = 0;
+    testDone = false;
+    for
+      await(const value of async([100, 200, 300, 400, 500])) {
+        'use strict';
+        // Ensure strict mode applies to block with use-strict-directive
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        sum += value;
+      }
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierConstDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternConstDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(const {key = 'unknown', value} of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternConstDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternConstDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [
+      {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
+      {key: 'last', value: 40}
+    ];
+    testDone = false;
+    for
+      await(const {key = 'unknown', value} of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternConstDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternConstDeclarationStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(const [key = 'unknown', value] of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternConstDeclarationStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternConstDeclarationBlockStatement() {
+    let sum = 0, keys = [];
+    let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
+    testDone = false;
+    for
+      await(const [key = 'unknown', value] of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternLetDeclarationBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
+  assertTrue(testDone);
+
+  // --------------------------------------------------------------------------
+
+  async function testBindingIdentifierLHSStatement() {
+    let sum = 0;
+    let value;
+    testDone = false;
+    for
+      await(value of async([100, 200, 300, 400, 500])) sum += value;
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierLHSStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testBindingIdentifierLHSBlockStatement() {
+    let sum = 0;
+    let value;
+    testDone = false;
+    for
+      await(value of async([100, 200, 300, 400, 500])) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        sum += value;
+      }
+    testDone = true;
+    return sum;
+  }
+
+  test = testBindingIdentifierLHSStatement();
+  assertFalse(testDone);
+  assertEquals(1500, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternLHSStatement() {
+    let sum = 0;
+    let keys = [];
+    let value;
+    let key;
+    let collection = [
+      {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
+      {key: 'last', value: 4}
+    ];
+    testDone = false;
+    for
+      await({key = 'unknown', value} of async(collection))
+      keys.push(key), sum += value;
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternLHSStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
+  assertTrue(testDone);
+
+  async function testObjectBindingPatternLHSBlockStatement() {
+    let sum = 0;
+    let keys = [];
+    let value;
+    let key;
+    let collection = [
+      {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
+      {key: 'last', value: 4}
+    ];
+    testDone = false;
+    for
+      await({key = 'unknown', value} of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testObjectBindingPatternLHSBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternLHSStatement() {
+    let sum = 0;
+    let keys = [];
+    let value;
+    let key;
+    let collection = [['first', 1], [undefined, 2], [, 3], ['last', 4]];
+    testDone = false;
+    for
+      await([key = 'unknown', value] of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternLHSStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
+  assertTrue(testDone);
+
+  async function testArrayBindingPatternLHSBlockStatement() {
+    let sum = 0;
+    let keys = [];
+    let value;
+    let key;
+    let collection = [
+      {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
+      {key: 'last', value: 4}
+    ];
+    testDone = false;
+    for
+      await({key = 'unknown', value} of async(collection)) {
+        'use strict';
+        assertDoesNotThrow(() => delete test.nonexistentProperty);
+        keys.push(key);
+        sum += value;
+      }
+    testDone = true;
+    return {keys, sum};
+  }
+
+  test = testArrayBindingPatternLHSBlockStatement();
+  assertFalse(testDone);
+  assertEquals(
+      {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
+  assertTrue(testDone);
+})().then(undefined, function(error) {
+  testFailed = true;
+  testFailure = error;
+});
+
+% RunMicrotasks();
+
+if (testFailed) {
+  print(testFailure.stack);
+  throw testFailure;
+}

[neis, 2017/01/20 14:38:16]

Great tests!

Please add some that exercise the iterator closing stuff.

And later also some that test the case of GetIterator where Symbol.asyncIterator
doesn't exist.

[caitp, 2017/01/20 20:17:19]

I think the tests where "Symbol.asyncIterator" isn't present will have to wait,
since currently the bytecode generator will call a runtime function which aborts
execution when that happens (I'm okay with this since the feature is behind a
flag).

That will all happen when the Async-from-Sync Iterator stuff lands, I guess.

About the IteratorClose stuff, I'm not fully aware of all of the interactions
that for-await-of should have with it.

It's basically just testing that it gets called in a specific order when break,
throw or return happens, right? If that's all it is, I'll add some new tests
shortly.