Stores and compound assignments for named super properties.

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() {
     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 15 matching lines @@
     constructor: Derived,
     _x: 'derived'
   };
   Derived.prototype.testGetter = function() {
     return super.x;
   }.toMethod(Derived.prototype);
   derived = new Derived();
   assertEquals('derived', derived.testGetter());
 }());
 
-/*
- * TODO[dslomov]: named stores and keyed loads/stores not implemented yet.
+
 (function TestSetter() {
   function Base() {}
   Base.prototype = {
     constructor: Base,
     get x() {
       return this._x;
     },
     set x(v) {
       this._x = v;
     },
     _x: 'base'
   };
 
   function Derived() {}
   Derived.__proto__ = Base;
   Derived.prototype = {
     __proto__: Base.prototype,
     constructor: Derived,
     _x: 'derived'
   };
   Derived.prototype.testSetter = function() {
-      super.x = 'foobar';
-    }.toMethod(Derived.prototype);
+    assertEquals('foobar', super.x = 'foobar');
+    assertEquals('foobarabc', super.x += 'abc');
+  }.toMethod(Derived.prototype);
   var d = new Derived();
   d.testSetter();
   assertEquals('base', Base.prototype._x);
-  assertEquals('foobar', d._x);
+  assertEquals('foobarabc', d._x);
+  d._x = '';
+  Derived.prototype.testSetterStrict = function() {
+    'use strict';
+    assertEquals('foobar', super.x = 'foobar');
+    assertEquals('foobarabc', super.x += 'abc');
+  }.toMethod(Derived.prototype);
+  d.testSetterStrict();
+  assertEquals('base', Base.prototype._x);
+  assertEquals('foobarabc', d._x);
 }());
 
 
-(function TestKeyedGetter() {
+(function TestSetterFailures() {
   function Base() {}
-  Base.prototype = {
-    constructor: Base,
-    _x: 'base'
-  };
+  function Derived() {}
+  Derived.prototype = { __proto__ : Base.prototype };
+  Derived.prototype.mSloppy = function () {
+    super.x = 10;
+    assertEquals(undefined, super.x);
+  }.toMethod(Derived.prototype);
 
-  Object.defineProperty(Base.prototype, '0',
-        { get: function() { return this._x; } });
+  Derived.prototype.mStrict = function () {
+    "use strict";
+    super.x = 10;
+  }.toMethod(Derived.prototype);
+  var d = new Derived();
+  d.mSloppy();
+  assertEquals(undefined, d.x);
+  var d1 = new Derived();
+  assertThrows(function() { d.mStrict(); }, ReferenceError);
+  assertEquals(undefined, d.x);
+}());
 
-  function Derived() {}
-  Derived.__proto__ = Base;
-  Derived.prototype = {
-    __proto__: Base.prototype,
-    constructor: Derived,
-    _x: 'derived'
-  };
-  Derived.prototype.testGetter = function() {
-      return super[0];
-    }.toMethod(Derived.prototype);
-  assertEquals('derived', new Derived()[0]);
-  // assertEquals('derived', new Derived().testGetter());
+
+(function TestUnsupportedCases() {
+  function f1(x) { return super[x]; }
+  var o = {}
+  assertThrows(function(){f1.toMethod(o)(x);}, ReferenceError);
+  function f2() { super.x++; }
+  assertThrows(function(){f2.toMethod(o)();}, ReferenceError);
 }());

[arv (Not doing code reviews), 2014/09/25 15:39:24]

Can you add a test of a strict function, used as a method that contains super
that is invoked with a value as this. Like I asked about...

function f() {
  'use strict';
  assertEquals(42, this);
  assertEquals(String.prototype.toString, super.toString);
  assertThrows('super.toString()',TypeError);
}
var g = f.toMethod(new String());
g.call(42);

[Dmitry Lomov (no reviews), 2014/09/26 10:35:26]

Done.

-*/