A64: Synchronize with r15204.

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 306 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"]);
 
+// Generator function instances.
+TestGenerator(GeneratorFunction(),
+              [undefined],
+              "foo",
+              [undefined]);
+
+TestGenerator(new GeneratorFunction(),
+              [undefined],
+              "foo",
+              [undefined]);
+
+TestGenerator(GeneratorFunction('yield 1;'),
+              [1, undefined],
+              "foo",
+              [1, undefined]);
+
+TestGenerator(
+    function() { return GeneratorFunction('x', 'y', 'yield x + y;')(1, 2) },
+    [3, undefined],
+    "foo",
+    [3, undefined]);
+
+// Test that yield* re-yields received results without re-boxing.
+function TestDelegatingYield() {
+  function results(results) {
+    var i = 0;
+    function next() {
+      return results[i++];
+    }
+    return { next: next }
+  }
+  function* yield_results(expected) {
+    return yield* results(expected);
+  }
+  function collect_results(iter) {
+    var ret = [];
+    var result;
+    do {
+      result = iter.next();
+      ret.push(result);
+    } while (!result.done);
+    return ret;
+  }
+  // We have to put a full result for the end, because the return will re-box.
+  var expected = [{value: 1}, 13, "foo", {value: 34, done: true}];
+
+  // Sanity check.
+  assertEquals(expected, collect_results(results(expected)));
+  assertEquals(expected, collect_results(yield_results(expected)));
+}
+TestDelegatingYield();
+
 function TestTryCatch(instantiate) {
   function* g() { yield 1; try { yield 2; } catch (e) { yield e; } yield 3; }
   function Sentinel() {}
 
   function Test1(iter) {
     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);
@@ skipping 242 matching lines @@
   function TestThrowRecursion() {
     function* g() { yield iter.throw(1); }
     var iter = g();
     return iter.next();
   }
   assertThrows(TestNextRecursion, Error);
   assertThrows(TestSendRecursion, Error);
   assertThrows(TestThrowRecursion, Error);
 }
 TestRecursion();