Implement yield* (delegating yield)

test/mjsunit/harmony/generators-iteration.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
@@ skipping 289 matching lines @@
         throw (yield (1 + (yield 2) + 3))
       } catch (e) {
         if (typeof e == 'object') throw e;
         return e + (yield (4 + (yield 5) + 6));
       }
     },
     [2, NaN, 5, NaN, NaN],
     "foo",
     [2, "1foo3", 5, "4foo6", "foofoo"]);
 
+// Delegating yield
+TestGenerator(
+    function* g26() {
+      function* g() { var x = yield 1; yield 2; yield x; return 3; }
+      yield* g();
+    },
+    [1, 2, undefined, undefined],
+    "foo",
+    [1, 2, "foo", undefined]);
+
 function TestTryCatch() {
   function* g() { yield 1; try { yield 2; } catch (e) { yield e; } yield 3; }
   function Sentinel() {}
   var iter;
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(undefined, true, iter.next());
@@ skipping 19 matching lines @@
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   var exn = new Sentinel;
   assertIteratorResult(exn, false, iter.throw(exn));
   assertIteratorResult(3, false, iter.next());
   assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
+  // ***
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   var exn = new Sentinel;
   assertIteratorResult(exn, false, iter.throw(exn));
   assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(undefined, true, iter.next());
   assertThrows(function() { iter.next(); }, Error);
+
+  // same as *** above with delegate

[rossberg, 2013/05/13 11:14:56]

Would be cool if all these Test functions were factored such that they take a
generator as argument and then run all tests with that. Then you could simply
invoke it twice with both the flat and the delegating generator (and potentially
other variations) and avoid code duplication.

+  iter = (function* () { yield* g(); })();
+  assertIteratorResult(1, false, iter.next());
+  assertIteratorResult(2, false, iter.next());
+  var exn = new Sentinel;
+  assertIteratorResult(exn, false, iter.throw(exn));
+  assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
+  assertThrows(function() { iter.next(); }, Error);
 }
 TestTryCatch();
 
 function TestTryFinally() {
   function* g() { yield 1; try { yield 2; } finally { yield 3; } yield 4; }
   function Sentinel() {}
   function Sentinel2() {}
   var iter;
 
   iter = g();
@@ skipping 13 matching lines @@
   assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.throw(new Sentinel));
   assertThrows(function() { iter.next(); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
+  // ***
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.throw(new Sentinel));
   assertThrows(function() { iter.throw(new Sentinel2); }, Sentinel2);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.next());
   assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(4, false, iter.next());
   assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(4, false, iter.next());
   assertIteratorResult(undefined, true, iter.next());
   assertThrows(function() { iter.next(); }, Error);
+
+  // same as *** above with delegate
+  iter = (function* () { yield* g(); })();
+  assertIteratorResult(1, false, iter.next());
+  assertIteratorResult(2, false, iter.next());
+  assertIteratorResult(3, false, iter.throw(new Sentinel));
+  assertThrows(function() { iter.throw(new Sentinel2); }, Sentinel2);
+  assertThrows(function() { iter.next(); }, Error);
 }
 TestTryFinally();
 
 function TestNestedTry() {
   function* g() {
     try {
       yield 1;
       try { yield 2; } catch (e) { yield e; }
       yield 3;
     } finally {
@@ skipping 34 matching lines @@
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   var exn = new Sentinel;
   assertIteratorResult(exn, false, iter.throw(exn));
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(4, false, iter.next());
   assertIteratorResult(5, false, iter.next());
   assertIteratorResult(undefined, true, iter.next());
   assertThrows(function() { iter.next(); }, Error);
 
+  // ***
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   var exn = new Sentinel;
   assertIteratorResult(exn, false, iter.throw(exn));
   assertIteratorResult(4, false, iter.throw(new Sentinel2));
   assertThrows(function() { iter.next(); }, Sentinel2);
   assertThrows(function() { iter.next(); }, Error);
 
   iter = g();
   assertIteratorResult(1, false, iter.next());
   assertIteratorResult(2, false, iter.next());
   var exn = new Sentinel;
   assertIteratorResult(exn, false, iter.throw(exn));
   assertIteratorResult(3, false, iter.next());
   assertIteratorResult(4, false, iter.throw(new Sentinel2));
   assertThrows(function() { iter.next(); }, Sentinel2);
   assertThrows(function() { iter.next(); }, Error);
 
+  // same as *** above with delegate
+  iter = (function* () { yield* g(); })();
+  assertIteratorResult(1, false, iter.next());
+  assertIteratorResult(2, false, iter.next());
+  var exn = new Sentinel;
+  assertIteratorResult(exn, false, iter.throw(exn));
+  assertIteratorResult(4, false, iter.throw(new Sentinel2));
+  assertThrows(function() { iter.next(); }, Sentinel2);
+  assertThrows(function() { iter.next(); }, Error);
+
   // That's probably enough.
 }
 TestNestedTry();
 
 function TestRecursion() {
   function TestNextRecursion() {
     function* g() { yield iter.next(); }
     var iter = g();
     return iter.next();
   }
   function TestSendRecursion() {
     function* g() { yield iter.send(42); }
     var iter = g();
     return iter.next();
   }
   function TestThrowRecursion() {
     function* g() { yield iter.throw(1); }
     var iter = g();
     return iter.next();
   }
   assertThrows(TestNextRecursion, Error);
   assertThrows(TestSendRecursion, Error);
   assertThrows(TestThrowRecursion, Error);
 }
 TestRecursion();