Implement iterator finalization in array destructuring.

test/mjsunit/harmony/iterator-close.js

 // 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-iterator-close

[adamk, 2016/03/07 20:28:05]

There are a ton of new tests in here, but I don't on first reading see any that
have errors on the LHS. For example, this case:

  log = []
  x = { set attr(_) { throw 1234; } };
  assertThrowsEquals(() => {
    [x.attr] = g();
  }, 1234);
  assertEquals([[]], log);

I think your patch probably does the right thing, but it would be good to
exercise such cases.

[neis, 2016/03/08 13:40:10]

Yes, definitely.  I added more.

 
+
 function* g() { yield 42; return 88 };
 
 
 // Return method is "undefined".
 {
   g.prototype.return = null;
 
+
+  assertEquals(undefined, (() => {
+    for (var x of g()) { break; }
+  })());
+
   assertEquals(undefined, (() => {
     for (let x of g()) { break; }
   })());
 
   assertEquals(undefined, (() => {
+    for (const x of g()) { break; }
+  })());
+
+  assertEquals(undefined, (() => {
     for (x of g()) { break; }
   })());
 
+
+  assertThrowsEquals(() => {
+    for (var x of g()) { throw 42; }
+  }, 42);
+
   assertThrowsEquals(() => {
     for (let x of g()) { throw 42; }
   }, 42);
 
   assertThrowsEquals(() => {
+    for (const x of g()) { throw 42; }
+  }, 42);
+
+  assertThrowsEquals(() => {
     for (x of g()) { throw 42; }
   }, 42);
 
+
+  assertEquals(42, (() => {
+    for (var x of g()) { return 42; }
+  })());
+
   assertEquals(42, (() => {
     for (let x of g()) { return 42; }
   })());
 
   assertEquals(42, (() => {
+    for (const x of g()) { return 42; }
+  })());
+
+  assertEquals(42, (() => {
     for (x of g()) { return 42; }
   })());
 
+
+  assertEquals(42, eval('for (var x of g()) { x; }'));
+
   assertEquals(42, eval('for (let x of g()) { x; }'));
 
-  assertEquals(42, eval('for (let x of g()) { x; }'));
+  assertEquals(42, eval('for (const x of g()) { x; }'));
+
+  assertEquals(42, eval('for (x of g()) { x; }'));
+
+
+  assertEquals(42, (() => {
+    var [x] = g(); return x;
+  })());
+
+  assertEquals(42, (() => {
+    let [x] = g(); return x;
+  })());
+
+  assertEquals(42, (() => {
+    const [x] = g(); return x;
+  })());
+
+  assertEquals(42, (() => {
+    [x] = g(); return x;
+  })());
 }
 
 
 // Return method is not callable.
 {
   g.prototype.return = 666;
 
+
+  assertThrows(() => {
+    for (var x of g()) { break; }
+  }, TypeError);
+
   assertThrows(() => {
     for (let x of g()) { break; }
   }, TypeError);
 
   assertThrows(() => {
+    for (const x of g()) { break; }
+  }, TypeError);
+
+  assertThrows(() => {
     for (x of g()) { break; }
   }, TypeError);
 
+
+  assertThrows(() => {
+    for (var x of g()) { throw 666; }
+  }, TypeError);
+
   assertThrows(() => {
     for (let x of g()) { throw 666; }
   }, TypeError);
 
   assertThrows(() => {
+    for (const x of g()) { throw 666; }
+  }, TypeError);
+
+  assertThrows(() => {
     for (x of g()) { throw 666; }
   }, TypeError);
 
+
+  assertThrows(() => {
+    for (var x of g()) { return 666; }
+  }, TypeError);
+
   assertThrows(() => {
     for (let x of g()) { return 666; }
   }, TypeError);
 
   assertThrows(() => {
+    for (const x of g()) { return 666; }
+  }, TypeError);
+
+  assertThrows(() => {
     for (x of g()) { return 666; }
   }, TypeError);
 
+
+  assertEquals(42, eval('for (var x of g()) { x; }'));
+
   assertEquals(42, eval('for (let x of g()) { x; }'));
 
-  assertEquals(42, eval('for (let x of g()) { x; }'));
+  assertEquals(42, eval('for (const x of g()) { x; }'));
+
+  assertEquals(42, eval('for (x of g()) { x; }'));
+
+
+  assertThrows(() => {
+    var [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    let [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    const [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    [x] = g(); return x;
+  }, TypeError);
 }
 
 
 // Return method does not return an object.
 {
   g.prototype.return = () => 666;
 
+
+  assertThrows(() => {
+    for (var x of g()) { break; }
+  }, TypeError);
+
   assertThrows(() => {
     for (let x of g()) { break; }
   }, TypeError);
 
   assertThrows(() => {
+    for (const x of g()) { break; }
+  }, TypeError);
+
+  assertThrows(() => {
     for (x of g()) { break; }
   }, TypeError);
 
+
   // Throw from the body of a for loop 'wins' vs throw
   // originating from a bad 'return' value.
+
+  assertThrowsEquals(() => {
+    for (var x of g()) { throw 666; }
+  }, 666);
+
   assertThrowsEquals(() => {
     for (let x of g()) { throw 666; }
   }, 666);
 
   assertThrowsEquals(() => {
+    for (const x of g()) { throw 666; }
+  }, 666);
+
+  assertThrowsEquals(() => {
     for (x of g()) { throw 666; }
   }, 666);
 
+
+  assertThrows(() => {
+    for (var x of g()) { return 666; }
+  }, TypeError);
+
   assertThrows(() => {
     for (let x of g()) { return 666; }
   }, TypeError);
 
   assertThrows(() => {
+    for (const x of g()) { return 666; }
+  }, TypeError);
+
+  assertThrows(() => {
     for (x of g()) { return 666; }
   }, TypeError);
 
+
+  assertEquals(42, eval('for (var x of g()) { x; }'));
+
   assertEquals(42, eval('for (let x of g()) { x; }'));
 
+  assertEquals(42, eval('for (const x of g()) { x; }'));
+
   assertEquals(42, eval('for (x of g()) { x; }'));
+
+
+  assertThrows(() => {
+    var [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    let [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    const [x] = g(); return x;
+  }, TypeError);
+
+  assertThrows(() => {
+    [x] = g(); return x;
+  }, TypeError);
 }
 
 
 // Return method returns an object.
 {
   let log = [];
   g.prototype.return = (...args) => { log.push(args); return {} };
 
+
+  log = [];
+  for (var x of g()) { break; }
+  assertEquals([[]], log);
+
   log = [];
   for (let x of g()) { break; }
   assertEquals([[]], log);
 
   log = [];
+  for (const x of g()) { break; }
+  assertEquals([[]], log);
+
+  log = [];
   for (x of g()) { break; }
   assertEquals([[]], log);
 
+
+  log = [];
+  assertThrowsEquals(() => {
+    for (var x of g()) { throw 42; }
+  }, 42);
+  assertEquals([[]], log);
+
   log = [];
   assertThrowsEquals(() => {
     for (let x of g()) { throw 42; }
   }, 42);
   assertEquals([[]], log);
 
   log = [];
   assertThrowsEquals(() => {
+    for (const x of g()) { throw 42; }
+  }, 42);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
     for (x of g()) { throw 42; }
   }, 42);
   assertEquals([[]], log);
 
+
+  log = [];
+  assertEquals(42, (() => {
+    for (var x of g()) { return 42; }
+  })());
+  assertEquals([[]], log);
+
   log = [];
   assertEquals(42, (() => {
     for (let x of g()) { return 42; }
   })());
   assertEquals([[]], log);
 
   log = [];
   assertEquals(42, (() => {
+    for (const x of g()) { return 42; }
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
     for (x of g()) { return 42; }
   })());
   assertEquals([[]], log);
 
+
+  log = [];
+  assertEquals(42, eval('for (var x of g()) { x; }'));
+  assertEquals([], log);
+
   log = [];
   assertEquals(42, eval('for (let x of g()) { x; }'));
   assertEquals([], log);
 
   log = [];
+  assertEquals(42, eval('for (const x of g()) { x; }'));
+  assertEquals([], log);
+
+  log = [];
   assertEquals(42, eval('for (x of g()) { x; }'));
   assertEquals([], log);
 
+
   // Even if doing the assignment throws, still call return
+  log = [];
   x = { set attr(_) { throw 1234; } };
   assertThrowsEquals(() => {
     for (x.attr of g()) { throw 456; }
   }, 1234);
   assertEquals([[]], log);
+
+
+  log = [];
+  assertEquals(42, (() => {
+    var [x] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    let [x] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    const [x] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    [x] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+
+  log = [];
+  assertEquals(42, (() => {
+    var [x,] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    let [x,] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    const [x,] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    [x,] = g(); return x;
+  })());
+  assertEquals([[]], log);
+
+
+  log = [];
+  assertEquals(42, (() => {
+    var [x,,] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    let [x,,] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    const [x,,] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals(42, (() => {
+    [x,,] = g(); return x;
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    var [x, y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    let [x, y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    const [x, y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    [x, y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([42], (() => {
+    var [...x] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    let [...x] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    const [...x] = g(); return x;
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    [...x] = g(); return x;
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([42, []], (() => {
+    var [x, ...y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, []], (() => {
+    let [x, ...y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, []], (() => {
+    const [x, ...y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, []], (() => {
+    [x, ...y] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([], (() => {
+    var [] = g(); return [];
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals([], (() => {
+    let [] = g(); return [];
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals([], (() => {
+    const [] = g(); return [];
+  })());
+  assertEquals([[]], log);
+
+  log = [];
+  assertEquals([], (() => {
+    [] = g(); return [];
+  })());
+  assertEquals([[]], log);
+
+
+  log = [];
+  assertEquals([], (() => {
+    var [...[]] = g(); return [];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([], (() => {
+    let [...[]] = g(); return [];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([], (() => {
+    const [...[]] = g(); return [];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([], (() => {
+    [...[]] = g(); return [];
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([42], (() => {
+    var [...[x]] = g(); return [x];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    let [...[x]] = g(); return [x];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    const [...[x]] = g(); return [x];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42], (() => {
+    [...[x]] = g(); return [x];
+  })());
+  assertEquals([], log);
+
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    var [...[x, y]] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    let [...[x, y]] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    const [...[x, y]] = g(); return [x, y];
+  })());
+  assertEquals([], log);
+
+  log = [];
+  assertEquals([42, undefined], (() => {
+    [...[x, y]] = g(); return [x, y];
+  })());
+  assertEquals([], log);
 }
 
 
 // Return method throws.
 {
   let log = [];
   g.prototype.return = (...args) => { log.push(args); throw 23 };
 
+
+  log = [];
+  assertThrowsEquals(() => {
+    for (var x of g()) { break; }
+  }, 23);
+  assertEquals([[]], log);
+
   log = [];
   assertThrowsEquals(() => {
     for (let x of g()) { break; }
   }, 23);
   assertEquals([[]], log);
 
   log = [];
   assertThrowsEquals(() => {
+    for (const x of g()) { break; }
+  }, 23);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
     for (x of g()) { break; }
   }, 23);
   assertEquals([[]], log);
 
+
+  log = [];
+  assertThrowsEquals(() => {
+    for (var x of g()) { throw 42; }
+  }, 42);
+  assertEquals([[]], log);
+
   log = [];
   assertThrowsEquals(() => {
     for (let x of g()) { throw 42; }
   }, 42);
   assertEquals([[]], log);
 
   log = [];
   assertThrowsEquals(() => {
+    for (const x of g()) { throw 42; }
+  }, 42);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
     for (x of g()) { throw 42; }
   }, 42);
   assertEquals([[]], log);
 
+
+  log = [];
+  assertThrowsEquals(() => {
+    for (var x of g()) { return 42; }
+  }, 23);
+  assertEquals([[]], log);
+
   log = [];
   assertThrowsEquals(() => {
     for (let x of g()) { return 42; }
   }, 23);
   assertEquals([[]], log);
 
   log = [];
   assertThrowsEquals(() => {
+    for (const x of g()) { return 42; }
+  }, 23);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
     for (x of g()) { return 42; }
   }, 23);
   assertEquals([[]], log);
 
+
+  log = [];
+  assertEquals(42, eval('for (var x of g()) { x; }'));
+  assertEquals([], log);
+
   log = [];
   assertEquals(42, eval('for (let x of g()) { x; }'));
   assertEquals([], log);
 
   log = [];
+  assertEquals(42, eval('for (const x of g()) { x; }'));
+  assertEquals([], log);
+
+  log = [];
   assertEquals(42, eval('for (x of g()) { x; }'));
   assertEquals([], log);
+
+  log = [];
+  assertThrowsEquals(() => {
+    var [x] = g(); return x;
+  }, 23);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
+    let [x] = g(); return x;
+  }, 23);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(() => {
+    const [x] = g(); return x;
+  }, 23);
+  assertEquals([[]], log);
+
+  log = [];
+  assertThrowsEquals(x => {
+    [x] = g(); return x;
+  }, 23);
+  assertEquals([[]], log);
 }
 
 
 // Next method throws.
 {
   g.prototype.next = () => { throw 666; };
   g.prototype.return = () => { assertUnreachable() };
 
+
+  assertThrowsEquals(() => {
+    for (var x of g()) {}
+  }, 666);
+
   assertThrowsEquals(() => {
     for (let x of g()) {}
   }, 666);
 
   assertThrowsEquals(() => {
+    for (const x of g()) {}
+  }, 666);
+
+  assertThrowsEquals(() => {
     for (x of g()) {}
   }, 666);
 }
 
 
 // Nested loops.
 {
   function* g1() { yield 1; yield 2; throw 3; }
   function* g2() { yield -1; yield -2; throw -3; }
 
@@ skipping 125 matching lines @@
     for (let x of g1()) {
       try {
         for (let y of g2()) {
         }
       } catch (_) {}
       if (x == 2) break;
     }
   }, 5);
   assertEquals([1], log);
 }