Baseline for-of implementation

test/mjsunit/harmony/iteration-semantics.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Flags: --harmony-iteration --harmony-scoping
+// Flags: --harmony-iteration --harmony-scoping --harmony-generators
 
 // Test for-of syntax.
 
 "use strict";
 

[Michael Starzinger, 2013/06/06 11:09:09]

Can we increase the test coverage for iterations. I was thinking about the
following cases which are not yet covered:

- Nested for-of statements, to verify that none of the internal ".result" and
".iterator" variables are destroyed.
- Using for-of on arbitrary iterator-like objects that have a next() method as
opposed to just generators.
- Using for-of on iterators that return non-standard result objects (e.g.
missing "done", missing "value", getters on these properties that count number
of accesses)
- Corner-cases where the the next() method is missing or disappears after a
certain number of iterations (to verify that the "iterator.next" lookup is
performed on every iteration).

[rossberg, 2013/06/06 11:35:33]

Also:

- interaction with exceptions
- ...and other non-local control flow (return, break/continue to outer loops)
- return objects with getters that throw
- iterators and/or return objects that are proxies

[wingo, 2013/06/06 17:10:06]

Done.

[wingo, 2013/06/06 17:10:06]

Not sure what you mean here.  Errors do seem to be thrown correctly and the
program continues as it should.  Do you mean a catch in a loop?
Done.
Done.
Surely if getters work, then proxies will work, right?

[rossberg, 2013/06/06 18:14:10]

Yes, some combinations of cases where an exception is thrown from different
places inside the loop or the iterator/generator, and caught/not caught
inside/outside the loop.
Oh, if only that was true... ;) Unfortunately, they could not be any more
different, and proxies tend to need annoying special casing all over the place.

Since iterators make non-trivial use of objects it would be great if you could
add tests for some proxy cases (preferably in a separate file). But I'm fine
with deferring that to a separate CL.

-function f() { for (x of y) { } }
-function f() { for (var x of y) { } }
-function f() { for (let x of y) { } }
+function* values() {
+  for (var i = 0; i < arguments.length; i++) {
+    yield arguments[i];
+  }
+}
 
-assertThrows("function f() { for (x of) { } }", SyntaxError);
-assertThrows("function f() { for (x of y z) { } }", SyntaxError);
-assertThrows("function f() { for (x of y;) { } }", SyntaxError);
+function* integers_from(n) {
+  while (1) yield n++;
+}
 
-assertThrows("function f() { for (var x of) { } }", SyntaxError);
-assertThrows("function f() { for (var x of y z) { } }", SyntaxError);
-assertThrows("function f() { for (var x of y;) { } }", SyntaxError);
+// A destructive append.
+function append(x, tail) {
+  tail[tail.length] = x;
+  return tail;
+}
 
-assertThrows("function f() { for (let x of) { } }", SyntaxError);
-assertThrows("function f() { for (let x of y z) { } }", SyntaxError);
-assertThrows("function f() { for (let x of y;) { } }", SyntaxError);
+function sum(x, tail) {
+  return x + tail;
+}
 
-// Alack, this appears to be valid.
-function f() { for (of of y) { } }
-function f() { for (let of of y) { } }
-function f() { for (var of of y) { } }
+// Normal termination.
+function fold(cons, seed, iter) {
+  for (var x of iter) {
+    seed = cons(x, seed);
+  }
+  return seed;
+}
 
-// This too, of course.
-function f() { for (of in y) { } }
-function f() { for (var of in y) { } }
-function f() { for (let of in y) { } }
+// Tests "break".
+function* take(iter, n) {
+  if (n == 0) return;
+  for (let x of iter) {
+    yield x;
+    if (--n == 0) break;
+  }
+}
+
+// Tests "continue".
+function* skip_every(iter, n) {
+  var i = 0;
+  for (let x of iter) {
+    if (++i % n == 0) continue;
+    yield x;
+  }
+}
+
+assertEquals([1, 2, 3], fold(append, [], values(1, 2, 3)));
+assertEquals(45, fold(sum, 0, take(integers_from(0), 10)));
+assertEquals(90, fold(sum, 0, take(skip_every(integers_from(0), 2), 10)));
+
+function* unreachable(iter) {
+  for (let x of iter) {
+    throw "not reached";
+  }
+}
+
+assertEquals(0, fold(sum, 0, unreachable(null)));

[rossberg, 2013/06/06 11:35:33]

Sigh...

+assertEquals(0, fold(sum, 0, unreachable(undefined)));
+
+assertThrows('fold(sum, 0, unreachable({}))', TypeError);
+assertThrows('fold(sum, 0, unreachable("foo"))', TypeError);
+assertThrows('fold(sum, 0, unreachable(37))', TypeError);