Keyed loads from super with numeric keys.

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 54 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 TestSuperNumericKeyedLoads() {
+  var x = 1;
+  var derivedDataProperty = 2;
+  var f = 3;
+  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 75 matching lines @@
     var ex = null;
     try {
       super[oThrowsInToString];
     } catch(e) { ex = e }
     assertEquals(eToThrow, ex);
 
     var oReturnsNumericString = { toString: function() {
       return "1";
     } };
 
-    ex = null;
-    try {
-      super[oReturnsNumericString];
-    } catch(e) { ex = e }
-    assertTrue(ex instanceof ReferenceError);
-
-    ex = null;
-    try {
-      super[1];  // Indexed properties unsupported yet.
-    } catch (e) { ex = e; }
-    assertTrue(ex instanceof ReferenceError);
+    assertEquals(undefined, super[oReturnsNumericString]);
+    assertEquals(undefined, super[1]);
   }.toMethod(Derived.prototype);
   derived = new Derived();
   assertEquals('derived', derived.testGetter());
+  derived = new Derived();
+  assertEquals('derived', derived.testGetterStrict());
+  derived = new Derived();
+  derived.testGetterWithToString();
+}());
+
+
+(function TestGetterNumericKeyed() {
+  var x = 42;
+  function Base() {}
+  var derived;
+  Base.prototype = {
+    constructor: Base,
+    _x: 'base'
+  };
+
+  Object.defineProperty(Base.prototype, x, { get: function() {
+      assertSame(this, derived);
+      return this._x;
+  }});
+
+  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 '42';
+    } };
+
+    toStringCalled = 0;
+    assertEquals('derived', super[o]);
+    assertEquals(1, toStringCalled);
+
+    var eToThrow = new Error();
+    var oThrowsInToString = { toString: function() {
+      throw eToThrow;
+    } };
+
+    var ex = null;
+    try {
+      super[oThrowsInToString];
+    } catch(e) { ex = e }
+    assertEquals(eToThrow, ex);
+
+    var oReturnsNumericString = { toString: function() {
+      return "42";
+    } };
+
+    assertEquals('derived', super[oReturnsNumericString]);
+    assertEquals('derived', super[42]);
+  }.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 = {
@@ skipping 895 matching lines @@
     this.fromDerived = v2;
   });
 
   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; }
+  function f(x) { super[x] = 5; }
   var o = {};
-  assertThrows(function(){f1.toMethod(o)(15);}, ReferenceError);
-  assertThrows(function(){f2.toMethod(o)(15);}, ReferenceError);
+  assertThrows(function(){f.toMethod(o)(15);}, ReferenceError);
 }());