Implement correct checking for inherited readonliness on assignment.

test/mjsunit/harmony/proxies.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 557 matching lines @@
 TestSetThrow(Proxy.create({
   get: function(pr, pk) {
     return function(r, k, v) { throw "myexn" }
   }
 }))
 
 
 var key
 var val
 
-function TestSetForDerived(handler) {
-  TestWithProxies(TestSetForDerived2, handler)
+function TestSetForDerived(trap) {
+  TestWithProxies(TestSetForDerived2, trap)
 }
 
-function TestSetForDerived2(create, handler) {
-  var p = create(handler)
+function TestSetForDerived2(create, trap) {
+  var p = create({getPropertyDescriptor: trap, getOwnPropertyDescriptor: trap})
   var o = Object.create(p, {x: {value: 88, writable: true},
                             '1': {value: 89, writable: true}})
 
   key = ""
   assertEquals(48, o.x = 48)
   assertEquals("", key)  // trap not invoked
   assertEquals(48, o.x)
 
   assertEquals(47, o[1] = 47)
   assertEquals("", key)  // trap not invoked
   assertEquals(47, o[1])
 
   assertEquals(49, o.y = 49)
   assertEquals("y", key)
   assertEquals(49, o.y)
 
   assertEquals(50, o[2] = 50)
   assertEquals("2", key)
   assertEquals(50, o[2])
 
   assertEquals(44, o.p_writable = 44)
   assertEquals("p_writable", key)
   assertEquals(44, o.p_writable)
 
   assertEquals(45, o.p_nonwritable = 45)
   assertEquals("p_nonwritable", key)
-  assertEquals(45, o.p_nonwritable)
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonwritable"))
 
+  assertThrows(function(){ "use strict"; o.p_nonwritable = 45 }, TypeError)
+  assertEquals("p_nonwritable", key)
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonwritable"))
+
+  val = ""
   assertEquals(46, o.p_setter = 46)
   assertEquals("p_setter", key)
   assertEquals(46, val)  // written to parent
   assertFalse(Object.prototype.hasOwnProperty.call(o, "p_setter"))
 
   val = ""
   assertEquals(47, o.p_nosetter = 47)
   assertEquals("p_nosetter", key)
   assertEquals("", val)  // not written at all
   assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nosetter"));
 
   key = ""
   assertThrows(function(){ "use strict"; o.p_nosetter = 50 }, TypeError)
   assertEquals("p_nosetter", key)
   assertEquals("", val)  // not written at all
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nosetter"));
 
   assertThrows(function(){ o.p_nonconf = 53 }, TypeError)
   assertEquals("p_nonconf", key)
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_nonconf"));
 
   assertThrows(function(){ o.p_throw = 51 }, "myexn")
   assertEquals("p_throw", key)
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_throw"));
 
   assertThrows(function(){ o.p_setterthrow = 52 }, "myexn")
   assertEquals("p_setterthrow", key)
+  assertFalse(Object.prototype.hasOwnProperty.call(o, "p_setterthrow"));
 }
 
-TestSetForDerived({
-  getPropertyDescriptor: function(k) {
+
+TestSetForDerived(
+  function(k) {
     key = k;
     switch (k) {
       case "p_writable": return {writable: true, configurable: true}
       case "p_nonwritable": return {writable: false, configurable: true}
-      case "p_setter":return {set: function(x) { val = x }, configurable: true}
-      case "p_nosetter": return {get: function() { return 1 }, configurable: true}
-      case "p_nonconf":return {}
+      case "p_setter": return {set: function(x) {val = x}, configurable: true}
+      case "p_nosetter": return {get: function() {return 1}, configurable: true}
+      case "p_nonconf": return {}
       case "p_throw": throw "myexn"
       case "p_setterthrow": return {set: function(x) { throw "myexn" }}
       default: return undefined
     }
   }
-})
+)
 
 
 // Evil proxy-induced side-effects shouldn't crash.
 // TODO(rossberg): proper behaviour isn't really spec'ed yet, so ignore results.
 
 TestWithProxies(function(create) {
   var calls = 0
   var handler = {
     getPropertyDescriptor: function() {
       ++calls
@@ skipping 1606 matching lines @@
 function TestConstructorWithProxyPrototype2(create, handler) {
   function C() {};
   C.prototype = create(handler);
 
   var o = new C;
   assertSame(C.prototype, o.__proto__);
   assertSame(C.prototype, Object.getPrototypeOf(o));
 }
 
 TestConstructorWithProxyPrototype();