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

test/mjsunit/harmony/classes-experimental.js

Index: test/mjsunit/harmony/classes-experimental.js
diff --git a/test/mjsunit/harmony/classes-experimental.js b/test/mjsunit/harmony/classes-experimental.js
index ed720d97b6275462e397d3f55e81746a450839f1..2c765a533e7f65ea5ad6fc18d43d9b34d28bce4e 100644
--- a/test/mjsunit/harmony/classes-experimental.js
+++ b/test/mjsunit/harmony/classes-experimental.js
@@ -5,63 +5,212 @@
 // Flags: --experimental-classes --harmony-classes
 
 'use strict';
+(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);
+    }
+  }
 
-class Base {
-  constructor(a, b) {
-    let o = new Object();
-    o.prp = a + b;
-    return o;
+  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() {}
   }
-}
-
-class Subclass extends Base {
-  constructor(a, b) {
-    var exn;
-    try {
-      this.prp1 = 3;
-    } catch (e) {
-      exn = e;
+
+  assertThrows(function() { new BadSubclass(); }, ReferenceError);
+}());
+
+(function TestPrototypeWiring() {
+  class Base {
+    constructor(x) {
+      this.foobar = x;
     }
-    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);
+  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 s = new Subclass(2, -1);
-assertSame(1, s.prp);
-assertSame(undefined, s.prp1);
-assertFalse(s.hasOwnProperty("prp1"));
+  let s1 = new Subclass(1,2);
+  assertSame(1, s1.foobar);
+  assertTrue(s1.__proto__ === Subclass.prototype);
 
-class Subclass2 extends Base {
-  constructor(x) {
-    super(1,2);
+  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);
 
-    if (x < 0) return;
+  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);
 
-    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);
+  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.

+    }
   }
-}
 
-var s2 = new Subclass2(1);
-assertSame(3, s2.prp);
+  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);
+    }
+  }
 
-var s3 = new Subclass2(-1);
-assertSame(3, s3.prp);
+  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);
 
-assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
-assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);
+  let s1 = new f(1);
+  assertSame(1, s1.x);
+  assertSame(undefined, s1.y);
+  assertTrue(s1.__proto__ === Subclass.prototype);
+}());