Represent implicit 'this' binding by 'super' in AST.

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-arrow-functions --allow-natives-syntax
 // Flags: --harmony-spreadcalls
 
 (function TestSuperNamedLoads() {
   function Base() { }
   function fBase() { }
@@ skipping 1961 matching lines @@
   var derivedDerivedCalled = 0;
 
   class Base {
     constructor() {
       baseCalled++;
     }
   }
 
   class Derived extends Base {
     constructor() {
-      super();
+      let r = super();
       derivedCalled++;

[rossberg, 2015/07/16 13:30:58]

Nit: any reason to separate the computation and the assert by this line?
(Similarly two cases below)

[Michael Starzinger, 2015/07/16 13:40:15]

Done. Nope, no reason, I just do these things to spice up my life a little. :)

+      assertEquals(this, r);
     }
   }
 
   assertEquals(Base, Base.prototype.constructor);
   assertEquals(Base.prototype, Derived.prototype.__proto__);
 
   baseCalled = 0;
   derivedCalled = 0;
   new Derived();
   assertEquals(1, baseCalled);
   assertEquals(1, derivedCalled);
 
   class DerivedDerived extends Derived {
     constructor() {
-      super();
+      let r = super();
       derivedDerivedCalled++;
+      assertEquals(this, r);
     }
   }
 
   baseCalled = 0;
   derivedCalled = 0;
   derivedDerivedCalled = 0;
   new DerivedDerived();
   assertEquals(1, baseCalled);
   assertEquals(1, derivedCalled);
   assertEquals(1, derivedDerivedCalled);
 
   class Base2 {
     constructor(v) {
       this.fromBase = v;
     }
   }
   class Derived2 extends Base2 {
     constructor(v1, v2) {
-      super(v1);
+      let r = super(v1);
       this.fromDerived = v2;
+      assertEquals(this, r);
     }
   }
 
   var d = new Derived2("base", "derived");
   assertEquals("base", d.fromBase);
   assertEquals("derived", d.fromDerived);
 
   var calls = 0;
   class G {
     constructor() {
@@ skipping 91 matching lines @@
 
 (function TestSuperCallInEval() {
   'use strict';
   class Base {
     constructor(x) {
       this.x = x;
     }
   }
   class Derived extends Base {
     constructor(x) {
-      eval('super(x)');
+      let r = eval('super(x)');
+      assertEquals(this, r);
     }
   }
   let d = new Derived(42);
   assertSame(42, d.x);
 })();
 
 
 (function TestSuperCallInArrow() {
   'use strict';
   class Base {
     constructor(x) {
       this.x = x;
     }
   }
   class Derived extends Base {
     constructor(x) {
-      (() => super(x))();
+      let r = (() => super(x))();
+      assertEquals(this, r);
     }
   }
   let d = new Derived(42);
   assertSame(42, d.x);
 })();
 
 
 (function TestSuperCallEscapes() {
   'use strict';
   class Base {
@@ skipping 65 matching lines @@
 
 (function TestSuperCallSpreadInEval() {
   'use strict';
   class Base {
     constructor(x) {
       this.x = x;
     }
   }
   class Derived extends Base {
     constructor(x) {
-      eval('super(...[x])');
+      let r = eval('super(...[x])');
+      assertEquals(this, r);
     }
   }
   let d = new Derived(42);
   assertSame(42, d.x);
 })();
 
 
 (function TestSuperCallSpreadInArrow() {
   'use strict';
   class Base {
     constructor(x) {
       this.x = x;
     }
   }
   class Derived extends Base {
     constructor(x) {
-      (() => super(...[x]))();
+      let r = (() => super(...[x]))();
+      assertEquals(this, r);
     }
   }
   let d = new Derived(42);
   assertSame(42, d.x);
 })();