Support count operations on super named 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() {
@@ skipping 207 matching lines @@
   }.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 TestCountOperations() {
+  function Base() {}
+  Base.prototype = {
+    constructor: Base,
+    get x() {
+      return this._x;
+    },
+    set x(v) {
+      this._x = v;
+    },
+    _x: 1
+  };
+
+  function Derived() {}
+  Derived.__proto__ = Base;
+  Derived.prototype = {
+    __proto__: Base.prototype,
+    constructor: Derived,
+    _x: 2
+  };
+
+  Derived.prototype.testCounts = function() {
+    assertEquals(2, this._x);
+    assertEquals(2, super.x);
+    super.x++;

[arv (Not doing code reviews), 2014/09/29 14:50:29]

Maybe wrap these in assertEquals to also assert the return value?

[Dmitry Lomov (no reviews), 2014/09/29 14:54:45]

No, these count operations without use of return values is a special case in
codegen, and I am testing precisely that.

+    assertEquals(3, super.x);
+    ++super.x;
+    assertEquals(4, super.x);
+    assertEquals(4, super.x++);
+    assertEquals(5, super.x);
+    assertEquals(6, ++super.x);
+    assertEquals(6, super.x);
+    assertEquals(6, this._x);
+
+    super.x--;
+    assertEquals(5, super.x);
+    --super.x;
+    assertEquals(4, super.x);
+    assertEquals(4, super.x--);
+    assertEquals(3, super.x);
+    assertEquals(2, --super.x);
+    assertEquals(2, super.x);
+    assertEquals(2, this._x);
+  }.toMethod(Derived.prototype);
+  new Derived().testCounts();
+}());
+
+
 (function TestUnsupportedCases() {
   function f1(x) { return super[x]; }
+  function f2(x) { super[x] = 5; }
   var o = {}
   assertThrows(function(){f1.toMethod(o)(x);}, ReferenceError);
-  function f2() { super.x++; }
-  assertThrows(function(){f2.toMethod(o)();}, ReferenceError);
+  assertThrows(function(){f2.toMethod(o)(x);}, ReferenceError);
 }());