new classes: implement new.target passing to superclass constructor.

test/mjsunit/harmony/classes-experimental.js

 // Copyright 2014 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: --experimental-classes --harmony-classes
 
 'use strict';
 
-class Base {
-  constructor(a, b) {
-    let o = new Object();
-    o.prp = a + b;
-    return o;
+(function TestThisAccessRestriction() {
+  class Base {
+    constructor(a, b) {
+      let o = new Object();
+      o.prp = a + b;
+      return o;
+    }
   }
-}
 
-class Subclass extends Base {
-  constructor(a, b) {
-    var exn;
-    try {
-      this.prp1 = 3;
-    } catch (e) {
-      exn = e;
+  class Subclass extends Base {
+    constructor(a, b) {
+      var exn;
+      try {
+        this.prp1 = 3;
+      } catch (e) {
+        exn = e;
+      }
+      assertTrue(exn instanceof ReferenceError);
+      super(a, b);
+      assertSame(a + b, this.prp);
+      assertSame(undefined, this.prp1);
+      assertFalse(this.hasOwnProperty("prp1"));
+      return this;
     }
-    assertTrue(exn instanceof ReferenceError);
-    super(a, b);
-    assertSame(a + b, this.prp);
-    assertSame(undefined, this.prp1);
-    assertFalse(this.hasOwnProperty("prp1"));
-    return this;
   }
-}
 
-let b = new Base(1, 2);
-assertSame(3, b.prp);
+  let b = new Base(1, 2);
+  assertSame(3, b.prp);
 
 
-let s = new Subclass(2, -1);
-assertSame(1, s.prp);
-assertSame(undefined, s.prp1);
-assertFalse(s.hasOwnProperty("prp1"));
+  let s = new Subclass(2, -1);
+  assertSame(1, s.prp);
+  assertSame(undefined, s.prp1);
+  assertFalse(s.hasOwnProperty("prp1"));
 
-class Subclass2 extends Base {
-  constructor(x) {
-    super(1,2);
+  class Subclass2 extends Base {
+    constructor(x) {
+      super(1,2);
 
-    if (x < 0) return;
+      if (x < 0) return;
 
-    let called = false;
-    function tmp() { called = true; return 3; }
-    var exn = null;
-    try {
-      super(tmp(),4);
-    } catch(e) { exn = e; }
-    assertTrue(exn !== null);
-    assertFalse(called);
+      let called = false;
+      function tmp() { called = true; return 3; }
+      var exn = null;
+      try {
+        super(tmp(),4);
+      } catch(e) { exn = e; }
+      assertTrue(exn !== null);
+      assertFalse(called);
+    }
   }
-}
 
-var s2 = new Subclass2(1);
-assertSame(3, s2.prp);
+  var s2 = new Subclass2(1);
+  assertSame(3, s2.prp);
 
-var s3 = new Subclass2(-1);
-assertSame(3, s3.prp);
+  var s3 = new Subclass2(-1);
+  assertSame(3, s3.prp);
 
-assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
-assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);
+  assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
+  assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);
+
+  class BadSubclass extends Base {
+    constructor() {}
+  }
+
+  assertThrows(function() { new BadSubclass(); }, ReferenceError);
+}());
+
+(function TestPrototypeWiring() {
+  class Base {
+    constructor(x) {
+      this.foobar = x;
+    }
+  }
+
+  class Subclass extends Base {
+    constructor(x) {
+      super(x);
+    }
+  }
+
+  let s = new Subclass(1);
+  assertSame(1, s.foobar);
+  assertTrue(s.__proto__ === Subclass.prototype);
+
+  let s1 = new Subclass(1,2);
+  assertSame(1, s1.foobar);
+  assertTrue(s1.__proto__ === Subclass.prototype);
+
+  let s2 = new Subclass();
+  assertSame(undefined, s2.foobar);
+  assertTrue(s2.__proto__ === Subclass.prototype);
+  assertThrows(function() { Subclass(1); }, TypeError);
+  assertThrows(function() { Subclass(1,2,3,4); }, TypeError);
+
+  class Subclass2 extends Subclass {
+    constructor() {
+      super(5,6,7);
+    }
+  }
+
+  let s_2 = new Subclass2();
+  assertSame(5, s_2.foobar);
+  assertTrue(s_2.__proto__ === Subclass2.prototype);
+
+  class Subclass3 extends Base {
+    constructor(x,y) {
+      super(x+y);
+    }
+  }
+
+  let s_3 = new Subclass3(27,42-27);
+  assertSame(42, s_3.foobar);
+  assertTrue(s_3.__proto__ === Subclass3.prototype);
+}());
+
+(function TestArgumentsAccess() {
+  class Base {
+    constructor() {
+      assertEquals(2, arguments.length);
+      assertEquals(1, arguments[0]);
+      assertEquals(2, arguments[1]);
+    }
+  }
+
+  let b = new Base(1,2);
+
+  class Subclass extends Base {
+    constructor() {
+      assertEquals(2, arguments.length);
+      assertEquals(3, arguments[0]);
+      assertEquals(4, arguments[1]);
+      super(1,2);
+    }
+  }
+
+  let s = new Subclass(3,4);
+
+  class Subclass2 extends Base {
+    constructor(x,y) {
+      assertEquals(2, arguments.length);
+      assertEquals(3, arguments[0]);
+      assertEquals(4, arguments[1]);
+      super(1,2);
+    }
+  }
+
+  let s2 = new Subclass2(3,4);
+}());
+
+
+(function TestSublclassingBuiltins() {
+  class ExtendedUint8Array extends Uint8Array {

[arv (Not doing code reviews), 2015/02/09 17:44:40]

HOT!

+    constructor() {
+      super(10);
+      this[0] = 255;
+      this[1] = 0xFFA;
+    }
+  }
+
+  var eua = new ExtendedUint8Array();
+  assertEquals(10, eua.length);
+  assertEquals(10, eua.byteLength);
+  assertEquals(0xFF, eua[0]);
+  assertEquals(0xFA, eua[1]);
+  assertTrue(eua.__proto__ === ExtendedUint8Array.prototype);

[arv (Not doing code reviews), 2015/02/09 17:44:40]

Maybe a test with Object.prototype.toString to make sure the instance is the
right exotic object kind.

[Dmitry Lomov (no reviews), 2015/02/10 19:22:15]

Done.

+}());
+
+(function TestSubclassingNull() {
+  let N = null;
+
+  class Foo extends N {
+    constructor(x,y) {
+      assertSame(1, x);
+      assertSame(2, y);
+      return new Object();
+    }
+  }
+
+  new Foo(1,2);
+}());