Revert of 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 36c4dd82465130b767c460bf67fcae9f2077eabc..ed720d97b6275462e397d3f55e81746a450839f1 100644
--- a/test/mjsunit/harmony/classes-experimental.js
+++ b/test/mjsunit/harmony/classes-experimental.js
@@ -5,223 +5,63 @@
 // Flags: --experimental-classes --harmony-classes
 
 'use strict';
-(function TestArgumentsAccess() {
-  class Base {
-    constructor() {
-      assertEquals(2, arguments.length);
-      assertEquals(1, arguments[0]);
-      assertEquals(2, arguments[1]);
+
+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);
-
-  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) {
-      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 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 instanceof ReferenceError);
-      // TODO(dslomov): should be 'true'.
-      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);
-
-  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);
-  assertSame(Subclass.prototype, s.__proto__);
-
-  let s1 = new Subclass(1, 2);
-  assertSame(1, s1.foobar);
-  assertTrue(s1.__proto__ === Subclass.prototype);
-
-  let s2 = new Subclass();
-  assertSame(undefined, s2.foobar);
-  assertSame(Subclass.prototype, s2.__proto__);
-  assertThrows(function() { Subclass(1); }, TypeError);
-  assertThrows(function() { Subclass(1,2,3,4); }, TypeError);
-
-  class Subclass2 extends Subclass {
-    constructor() {
-      super(5, 6, 7);
-    }
-  }
-
-  let ss2 = new Subclass2();
-  assertSame(5, ss2.foobar);
-  assertSame(Subclass2.prototype, ss2.__proto__);
-
-  class Subclass3 extends Base {
-    constructor(x,y) {
-      super(x + y);
-    }
-  }
-
-  let ss3 = new Subclass3(27,42-27);
-  assertSame(42, ss3.foobar);
-  assertSame(Subclass3.prototype, ss3.__proto__);
-}());
-
-(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 Foo(1,2);
-}());
-
-(function TestSubclassBinding() {
-  class Base {
-    constructor(x, y) {
-      this.x = x;
-      this.y = y;
-    }
-  }
-
-  let obj = {};
-  class Subclass extends Base {
-    constructor(x,y) {
-      super(x,y);
-      assertTrue(this !== obj);
-    }
-  }
-
-  let f = Subclass.bind(obj);
-  assertThrows(function () { f(1, 2); }, TypeError);
-  let s = new f(1, 2);
-  assertSame(1, s.x);
-  assertSame(2, s.y);
-  assertSame(Subclass.prototype, s.__proto__);
-
-  let s1 = new f(1);
-  assertSame(1, s1.x);
-  assertSame(undefined, s1.y);
-  assertSame(Subclass.prototype, s1.__proto__);
-
-  let g = Subclass.bind(obj, 1);
-  assertThrows(function () { g(8); }, TypeError);
-  let s2 = new g(8);
-  assertSame(1, s2.x);
-  assertSame(8, s2.y);
-  assertSame(Subclass.prototype, s.__proto__);
-}());
+assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
+assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);