Reland "[es6] Fix Function and GeneratorFunction built-ins subclassing."

test/mjsunit/es6/classes-subclass-builtins.js

 // Copyright 2015 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: --allow-natives-syntax
 
 "use strict";
 
 
 function checkPrototypeChain(object, constructors) {
   var proto = object.__proto__;
   for (var i = 0; i < constructors.length; i++) {
     assertEquals(constructors[i].prototype, proto);
     assertEquals(constructors[i], proto.constructor);
     proto = proto.__proto__;
   }
 }
 
 
 (function() {
+  class A extends Function {
+    constructor(...args) {
+      assertTrue(%IsConstructCall());
+      super(...args);
+      this.a = 42;
+      this.d = 4.2;
+    }
+  }
+
+  var o = new A("this.foo = 153;");
+  assertTrue(o instanceof Object);
+  assertTrue(o instanceof Function);
+  assertTrue(o instanceof A);
+  assertEquals("function", typeof o);
+  checkPrototypeChain(o, [A, Function, Object]);
+  assertEquals(42, o.a);
+  assertEquals(4.2, o.d);
+  var oo = new o();
+  assertEquals(153, oo.foo);
+
+  var o1 = new A("return 312;");
+  assertTrue(%HaveSameMap(o, o1));
+})();
+
+
+(function() {
   class A extends Boolean {
     constructor(...args) {
       assertTrue(%IsConstructCall());
       super(...args);
       this.a = 42;
       this.d = 4.2;
     }
   }
 
   var o = new A(true);
@@ skipping 287 matching lines @@
   assertEquals(42, o.a);
   assertEquals(4.2, o.d);
 
   var o1 = new A(buffer);
   assertTrue(%HaveSameMap(o, o1));
 
 })();
 
 
 (function() {
+  // TODO(ishell): remove once GeneratorFunction is available.
+  var GeneratorFunction = (function*() {}).__proto__.constructor;
+  class A extends GeneratorFunction {
+    constructor(...args) {
+      assertTrue(%IsConstructCall());
+      super(...args);
+      this.a = 42;
+      this.d = 4.2;
+    }
+  }
+  var generator_func = new A("var index = 0; while (index < 5) { yield ++index; }");
+  assertTrue(generator_func instanceof Object);
+  assertTrue(generator_func instanceof Function);
+  assertTrue(generator_func instanceof GeneratorFunction);
+  assertTrue(generator_func instanceof A);
+  assertEquals("function", typeof generator_func);
+  checkPrototypeChain(generator_func, [A, GeneratorFunction, Function, Object]);
+  assertEquals(42, generator_func.a);
+  assertEquals(4.2, generator_func.d);
+
+  var o = new generator_func();
+  assertTrue(o instanceof Object);
+  assertTrue(o instanceof generator_func);
+  assertEquals("object", typeof o);
+
+  assertPropertiesEqual({done: false, value: 1}, o.next());
+  assertPropertiesEqual({done: false, value: 2}, o.next());
+  assertPropertiesEqual({done: false, value: 3}, o.next());
+  assertPropertiesEqual({done: false, value: 4}, o.next());
+  assertPropertiesEqual({done: false, value: 5}, o.next());
+  assertPropertiesEqual({done: true, value: undefined}, o.next());
+
+  var generator_func1 = new A("return 0;");
+  assertTrue(%HaveSameMap(generator_func, generator_func1));
+})();
+
+
+(function() {
   class A extends Boolean {
     constructor() {
       assertTrue(%IsConstructCall());
       super(true);
       this.a00 = 0
       this.a01 = 0
       this.a02 = 0
       this.a03 = 0
       this.a04 = 0
       this.a05 = 0
@@ skipping 89 matching lines @@
 (function() {
   class A extends null {}
   assertThrows("new A");
 })();
 
 
 (function() {
   class A extends Symbol {}
   assertThrows("new A");
 })();