new classes: implement correct check for uninitialized this in 'super()'

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';
 (function TestArgumentsAccess() {
   class Base {
     constructor() {
@@ skipping 71 matching lines @@
 
       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);
+      assertTrue(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 TestThisCheckOrdering() {
+  let baseCalled = 0;
+  class Base {
+    constructor() { baseCalled++ }
+  }
+
+  let fCalled = 0;
+  function f() { fCalled++; return 3; }
+
+  class Subclass1 extends Base {
+    constructor() {
+      baseCalled = 0;
+      super();
+      assertEquals(1, baseCalled);
+      let obj = this;
+
+      let exn = null;
+      baseCalled = 0;
+      fCalled = 0;
+      try {
+        super(f());
+      } catch (e) { exn = e; }
+      assertTrue(exn instanceof ReferenceError);
+      assertEquals(1, fCalled);
+      assertEquals(1, baseCalled);
+      assertSame(obj, this);
+
+      exn = null;
+      baseCalled = 0;
+      fCalled = 0;
+      try {
+        super(super(), f());
+      } catch (e) { exn = e; }
+      assertTrue(exn instanceof ReferenceError);
+      assertEquals(0, fCalled);
+      assertEquals(1, baseCalled);
+      assertSame(obj, this);
+
+      exn = null;
+      baseCalled = 0;
+      fCalled = 0;
+      try {
+        super(f(), super());
+      } catch (e) { exn = e; }
+      assertTrue(exn instanceof ReferenceError);
+      assertEquals(1, fCalled);
+      assertEquals(1, baseCalled);
+      assertSame(obj, this);
+    }
+  }
+
+  new Subclass1();
+}());
+
+
 (function TestPrototypeWiring() {
   class Base {
     constructor(x) {
       this.foobar = x;
     }
   }
 
   class Subclass extends Base {
     constructor(x) {
       super(x);
@@ skipping 153 matching lines @@
   var eua = new ExtendedUint8Array(10);
   assertEquals(10, eua.length);
   assertEquals(10, eua.byteLength);
   eua[0] = 0xFF;
   eua[1] = 0xFFA;
   assertEquals(0xFF, eua[0]);
   assertEquals(0xFA, eua[1]);
   assertSame(ExtendedUint8Array.prototype, eua.__proto__);
   assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
 }());