new classes: no longer experimental.

test/mjsunit/harmony/classes.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: --harmony-classes --harmony-sloppy
 
 (function TestBasics() {
   var C = class C {}
   assertEquals(typeof C, 'function');
   assertEquals(C.__proto__, Function.prototype);
@@ skipping 121 matching lines @@
 })();
 
 
 (function TestSuperInConstructor() {
   var calls = 0;
   class B {}
   B.prototype.x = 42;
 
   class C extends B {
     constructor() {
+      super();
       calls++;
       assertEquals(42, super.x);
     }
   }
 
   new C;
   assertEquals(1, calls);
 })();
 
 
@@ skipping 454 matching lines @@
   assertEquals(1, new C()[1]());
   assertEquals(2, new C()[2]);
   assertEquals(4, C[4]());
   assertEquals(5, C[5]);
 })();
 
 
 (function TestDefaultConstructorNoCrash() {
   // Regression test for https://code.google.com/p/v8/issues/detail?id=3661
   class C {}
-  assertEquals(undefined, C());
-  assertEquals(undefined, C(1));
+  assertThrows(function () {C();}, TypeError);
+  assertThrows(function () {C(1);}, TypeError);
   assertTrue(new C() instanceof C);
   assertTrue(new C(1) instanceof C);
 })();
 
 
 (function TestDefaultConstructor() {
   var calls = 0;
   class Base {
     constructor() {
       calls++;
     }
   }
   class Derived extends Base {}
   var object = new Derived;
   assertEquals(1, calls);
 
   calls = 0;
-  Derived();
-  assertEquals(1, calls);
+  assertThrows(function() { Derived(); }, TypeError);
+  assertEquals(0, calls);
 })();
 
 
 (function TestDefaultConstructorArguments() {
   var args, self;
   class Base {
     constructor() {
       self = this;
       args = arguments;
     }
   }
   class Derived extends Base {}
 
   new Derived;
   assertEquals(0, args.length);
 
   new Derived(0, 1, 2);
   assertEquals(3, args.length);
   assertTrue(self instanceof Derived);
 
   var arr = new Array(100);
   var obj = {};
-  Derived.apply(obj, arr);
-  assertEquals(100, args.length);
-  assertEquals(obj, self);
+  assertThrows(function() {Derived.apply(obj, arr);}, TypeError);
 })();
 
 
 (function TestDefaultConstructorArguments2() {
   var args;
   class Base {
     constructor(x, y) {
       args = arguments;
     }
   }
@@ skipping 104 matching lines @@
   assertThrows(function() {
     (class x extends x {});
   }, ReferenceError);
 
   assertThrows(function() {
     var x = (class x extends x {});
   }, ReferenceError);
 })();
 
 
-(function TestSuperCallSyntacticRestriction() {
-  assertThrows(function() {
-    class C {
+(function TestThisAccessRestriction() {
+  class Base {}
+  (function() {
+    class C extends Base {
       constructor() {
         var y;
         super();
       }
     }; new C();
-  }, TypeError);
+  }());
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super(this.x);
       }
     }; new C();
-  }, TypeError);
+  }, ReferenceError);
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super(this);
       }
     }; new C();
-  }, TypeError);
+  }, ReferenceError);
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super.method();
         super(this);
       }
     }; new C();
-  }, TypeError);
+  }, ReferenceError);
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super(super.method());
       }
     }; new C();
-  }, TypeError);
+  }, ReferenceError);
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super(super());
       }
     }; new C();
-  }, TypeError);
+  }, ReferenceError);
   assertThrows(function() {
-    class C {
+    class C extends Base {
       constructor() {
         super(1, 2, Object.getPrototypeOf(this));
       }
     }; new C();
-  }, TypeError);
-  assertThrows(function() {
-    class C {
+  }, ReferenceError);
+  (function() {
+    class C extends Base {
       constructor() {
         { super(1, 2); }
       }
     }; new C();
-  }, TypeError);
-  assertThrows(function() {
-    class C {
+  }());
+  (function() {
+    class C extends Base {
       constructor() {
         if (1) super();
       }
     }; new C();
-  }, TypeError);
+  }());
 
   class C1 extends Object {
     constructor() {
       'use strict';
       super();
     }
   };
   new C1();
 
   class C2 extends Object {
     constructor() {
       ; 'use strict';;;;;
       super();
     }
   };
   new C2();
 
   class C3 extends Object {
     constructor() {
       ; 'use strict';;;;;
       // This is a comment.
       super();
     }
   };
   new C3();
 }());