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 ImplicitSubclassOfFunction() {
+    super();
+    this.x = 123;
+  }
+
+  var o = new ImplicitSubclassOfFunction();
+  assertEquals(123, o.x);
+
+  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);
 }());
 
 
+(function TestSuperCallErrorCases() {
+  function T() {
+    super();
+  }
+  T.__proto__ = null;
+  // Spec says ReferenceError here, but for other IsCallable failures
+  // we throw TypeError.
+  // Filed https://bugs.ecmascript.org/show_bug.cgi?id=3282
+  assertThrows(function() { new T(); }, TypeError);
+}());
+
+
 (function TestUnsupportedCases() {
   function f(x) { super[x] = 5; }
   var o = {};
   assertThrows(function(){f.toMethod(o)(15);}, ReferenceError);
 }());