Support for super keyed loads where key is a name.

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 19 matching lines @@
   Base.prototype.toString = function() { return "this is Base"; };
   Derived.prototype.toString = function() { return "this is Derived"; };
   Derived.prototype.x = 27;
   Derived.prototype.f = fDerived.toMethod(Derived.prototype);
 
   assertEquals("Base this is Base", new Base().f());
   assertEquals("Derived", new Derived().f());
 }());
 
 
+(function TestSuperKeyedLoads() {
+  var x = 'x';
+  var derivedDataProperty = 'derivedDataProperty';
+  var f = 'f';
+  function Base() { }
+  function Derived() {
+    this[derivedDataProperty] = "xxx";
+  }
+  Derived.prototype = Object.create(Base.prototype);
+
+  function fBase() { return "Base " + this.toString(); }
+
+  Base.prototype[f] = fBase.toMethod(Base.prototype);
+
+  function fDerived() {
+     assertEquals("Base this is Derived", super[f]());
+     var a = super[x];
+     assertEquals(15, a);
+     assertEquals(15, super[x]);
+     assertEquals(27, this[x]);
+
+     return "Derived"
+  }
+
+  Base.prototype[x] = 15;
+  Base.prototype.toString = function() { return "this is Base"; };
+  Derived.prototype.toString = function() { return "this is Derived"; };
+  Derived.prototype[x] = 27;
+  Derived.prototype[f] = fDerived.toMethod(Derived.prototype);
+
+  assertEquals("Base this is Base", new Base().f());
+  assertEquals("Derived", new Derived().f());
+}());
+
+
 (function TestSuperKeywordNonMethod() {
   function f() {
     super.unknown();
   }
 
   assertThrows(f, ReferenceError);
 }());
 
 
 (function TestGetter() {
@@ skipping 22 matching lines @@
     'use strict';
     return super.x;
   }.toMethod(Derived.prototype);
   derived = new Derived();
   assertEquals('derived', derived.testGetter());
   derived = new Derived();
   assertEquals('derived', derived.testGetterStrict());
 }());
 
 
+(function TestGetterKeyed() {
+  var x = 'x';
+  function Base() {}
+  var derived;
+  Base.prototype = {
+    constructor: Base,
+    get x() {
+      assertSame(this, derived);
+      return this._x;
+    },
+    _x: 'base'
+  };
+
+  function Derived() {}
+  Derived.__proto__ = Base;
+  Derived.prototype = {
+    __proto__: Base.prototype,
+    constructor: Derived,
+    _x: 'derived'
+  };
+  Derived.prototype.testGetter = function() {
+    return super[x];
+  }.toMethod(Derived.prototype);
+  Derived.prototype.testGetterStrict = function() {
+    'use strict';
+    return super[x];
+  }.toMethod(Derived.prototype);
+  Derived.prototype.testGetterWithToString = function() {
+    var toStringCalled;
+    var o = { toString: function() {
+      toStringCalled++;
+      return 'x';
+    } };
+
+    toStringCalled = 0;
+    assertEquals('derived', super[o]);
+    assertEquals(1, toStringCalled);
+
+    var ex;
+    try {
+      super[1];  // Indexed properties unsupported yet.
+    } catch (e) { ex = e; }
+    assertTrue(ex instanceof ReferenceError);
+  }.toMethod(Derived.prototype);
+  derived = new Derived();
+  assertEquals('derived', derived.testGetter());
+  derived = new Derived();
+  assertEquals('derived', derived.testGetterStrict());
+  derived = new Derived();
+  derived.testGetterWithToString();
+}());
+
+
 (function TestSetter() {
   function Base() {}
   Base.prototype = {
     constructor: Base,
     get x() {
       return this._x;
     },
     set x(v) {
       this._x = v;
     },
@@ skipping 437 matching lines @@
   var d = new Derived2("base", "derived");
   assertEquals("base", d.fromBase);
   assertEquals("derived", d.fromDerived);
 }());
 
 
 (function TestUnsupportedCases() {
   function f1(x) { return super[x]; }
   function f2(x) { super[x] = 5; }
   var o = {};
-  assertThrows(function(){f1.toMethod(o)(x);}, ReferenceError);
-  assertThrows(function(){f2.toMethod(o)(x);}, ReferenceError);
+  assertThrows(function(){f2.toMethod(o)(15);}, ReferenceError);
+  assertThrows(function(){f2.toMethod(o)(15);}, ReferenceError);
 }());