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;
-  }
-}
-
-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;
-  }
-}
-
-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"));
-
-class Subclass2 extends Base {
-  constructor(x) {
-    super(1,2);
-
-    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);
-  }
-}
-
-var s2 = new Subclass2(1);
-assertSame(3, s2.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);
+(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);
+  assertEquals(0, Subclass.length);
+
+  class Subclass2 extends Base {
+    constructor(x,y) {

[arv (Not doing code reviews), 2015/02/10 20:15:18]

ws after commma

+      assertEquals(2, arguments.length);
+      assertEquals(3, arguments[0]);
+      assertEquals(4, arguments[1]);
+      super(1,2);
+    }
+  }
+
+  let s2 = new Subclass2(3,4);
+  assertEquals(2, Subclass2.length);
+}());
+
+(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;
+      }
+      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 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);
+
+      if (x < 0) return;
+
+      let called = false;
+      function tmp() { called = true; return 3; }
+      var exn = null;
+      try {
+        super(tmp(),4);

[arv (Not doing code reviews), 2015/02/10 20:15:18]

Because left to right execution?

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

I realized this is not correct under the new spec. super call needs to happen
and then we validate that 'this' has not been initialized yet. I'll fix in
sparate CL (this CL does not change that behaviour)

+      } catch(e) { exn = e; }

[arv (Not doing code reviews), 2015/02/10 20:15:18]

ws after catch

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+      assertTrue(exn !== null);

[arv (Not doing code reviews), 2015/02/10 20:15:18]

instanceof test would be better

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+      assertFalse(called);
+    }
+  }
+
+  var s2 = new Subclass2(1);
+  assertSame(3, s2.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);
+
+  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);

[arv (Not doing code reviews), 2015/02/10 20:15:18]

assertSame here too

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+
+  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();

[arv (Not doing code reviews), 2015/02/10 20:15:18]

no underscores in js

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+  assertSame(5, s_2.foobar);
+  assertTrue(s_2.__proto__ === Subclass2.prototype);
+
+  class Subclass3 extends Base {
+    constructor(x,y) {
+      super(x+y);

[arv (Not doing code reviews), 2015/02/10 20:15:18]

ws around binops

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+    }
+  }
+
+  let s_3 = new Subclass3(27,42-27);
+  assertSame(42, s_3.foobar);
+  assertTrue(s_3.__proto__ === Subclass3.prototype);
+}());
+
+(function TestSublclassingBuiltins() {
+  class ExtendedUint8Array extends Uint8Array {
+    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);
+  assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
+}());
+
+(function TestSubclassingNull() {
+  let N = null;
+
+  class Foo extends N {
+    constructor(x,y) {
+      assertSame(1, x);
+      assertSame(2, y);
+      return new Object();

[arv (Not doing code reviews), 2015/02/10 20:15:18]

in general, prefer {} over new Object()

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+    }
+  }
+
+  new Foo(1,2);
+}());
+
+(function TestSubclassBinding() {
+  class Base {
+    constructor(x, y) {
+      this.x = x;
+      this.y = y;
+    }
+  }
+  class Subclass extends Base {
+    constructor(x,y) {
+      super(x,y);
+    }
+  }
+
+  let f = Subclass.bind(new Object());

[arv (Not doing code reviews), 2015/02/10 20:15:18]

Bind a parameter too.

let f = Subclass.bind({}, 1);

[arv (Not doing code reviews), 2015/02/10 20:15:18]

maybe

let obj = {};
let f = Subclass.bind(obj);

and assert that `this !== obj` in the constructor.

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

[Dmitry Lomov (no reviews), 2015/02/11 00:58:29]

Done.

+  assertThrows(function () { f(1,2); }, TypeError);
+  let s = new f(1,2);
+  assertSame(1, s.x);
+  assertSame(2, s.y);
+  assertTrue(s.__proto__ === Subclass.prototype);
+
+  let s1 = new f(1);
+  assertSame(1, s1.x);
+  assertSame(undefined, s1.y);
+  assertTrue(s1.__proto__ === Subclass.prototype);
+}());