Implement the new semantics for 'super(...)'

test/mjsunit/harmony/super.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
 
 
 (function TestSuperNamedLoads() {
   function Base() { }
   function Derived() {
@@ skipping 1174 matching lines @@
     assertEquals(2, --super[x]);
     assertEquals(2, super[x]);
     assertEquals(2, this._x);
   }.toMethod(Derived.prototype);
   new Derived().testCounts();
 }());
 
 
 (function TestSuperCall() {
   function Subclass(base, constructor) {
-    var homeObject = { __proto__ : base.prototype };
-    var result = constructor.toMethod(homeObject);
-    homeObject.constructor = result;
-    result.prototype = homeObject;
-    return result;
+    var homeObject = {
+      __proto__: base.prototype,
+      constructor: constructor
+    };
+    constructor.__proto__ = base;
+    constructor.prototype = homeObject;
+    // not doing toMethod: home object is not required for
+    // super constructor calls.
+    return constructor;
   }
 
   var baseCalled = 0;
   var derivedCalled = 0;
   var derivedDerivedCalled = 0;
 
   function Base() {
     baseCalled++;
   }
 
@@ skipping 28 matching lines @@
     this.fromBase = v;
   }
   var Derived2 = Subclass(Base2, function (v1, v2) {
     super(v1);
     this.fromDerived = v2;
   });
 
   var d = new Derived2("base", "derived");
   assertEquals("base", d.fromBase);
   assertEquals("derived", d.fromDerived);
+
+  function ImplicitSubclassOfObject() {
+    super();

[arv (Not doing code reviews), 2014/10/15 14:47:18]

Just to be clear that I understand this. This one calls?

ImplicitSubclassOfObject.__proto__.call(ImplicitSubclassOfObject);

which happens to be

Function.prototype.call(ImplicitSubclassOfObject);

[Dmitry Lomov (no reviews), 2014/10/15 17:22:57]

You are right, this has to be called ImplicitSubclassOfFunction.
Renamed.

+    this.x = 123;
+  }
+
+  var o = new ImplicitSubclassOfObject();
+  assertEquals(123, o.x);
 }());
 
 
+(function TestSuperCallErrorCases() {
+  function T() {
+    super();
+  }
+  T.__proto__ = null;
+  // Spec says ReferenceError here, but for other IsCallable failures
+  // we throw TypeError.

[arv (Not doing code reviews), 2014/10/15 14:47:18]

Completely agree. I was reading up on the changes to the spec in preparation for
this CL and it should obviously by TypeError.

+  // Filed https://bugs.ecmascript.org/show_bug.cgi?id=3282
+  assertThrows(function() { new T(); }, TypeError);
+}());

[arv (Not doing code reviews), 2014/10/15 14:49:54]

maybe add a test that mutates __proto__ and then uses the new proto?

var calls = 0;
function G() {
  calls++;
}
function F() {}
  super();
}
F.__proto__ = G;
new F();
assertEquals(1, calls);
F.__proto__ = function() {};
new F();
assertEquals(1, calls);

[Dmitry Lomov (no reviews), 2014/10/15 17:22:57]

Done.

+
+
 (function TestUnsupportedCases() {
   function f(x) { super[x] = 5; }
   var o = {};
   assertThrows(function(){f.toMethod(o)(15);}, ReferenceError);
 }());