[proxies] Remove "fix" functionality, add (still unused) target property.

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 1806 matching lines @@
   },
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 
 
 // Fixing (Object.freeze, Object.seal, Object.preventExtensions,
 //         Object.isFrozen, Object.isSealed, Object.isExtensible)
 
 function TestFix(names, handler) {
-  var proto = {p: 77}
-  var assertFixing = function(o, s, f, e) {
-    assertEquals(s, Object.isSealed(o))
-    assertEquals(f, Object.isFrozen(o))
-    assertEquals(e, Object.isExtensible(o))
-  }
-
-  var p1 = Proxy.create(handler, proto)
-  assertFixing(p1, false, false, true)
-  Object.seal(p1)
-  assertFixing(p1, true, names.length === 0, false)
-  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p1).sort())
-  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
-                    Object.keys(p1).sort())
-  assertEquals(proto, Object.getPrototypeOf(p1))
-  assertEquals(77, p1.p)
-  for (var n in p1) {
-    var desc = Object.getOwnPropertyDescriptor(p1, n)
-    if (desc !== undefined) assertFalse(desc.configurable)
-  }
-
-  var p2 = Proxy.create(handler, proto)
-  assertFixing(p2, false, false, true)
-  Object.freeze(p2)
-  assertFixing(p2, true, true, false)
-  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p2).sort())
-  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
-                    Object.keys(p2).sort())
-  assertEquals(proto, Object.getPrototypeOf(p2))
-  assertEquals(77, p2.p)
-  for (var n in p2) {
-    var desc = Object.getOwnPropertyDescriptor(p2, n)
-    if (desc !== undefined) assertFalse(desc.writable)
-    if (desc !== undefined) assertFalse(desc.configurable)
-  }
-
-  var p3 = Proxy.create(handler, proto)
-  assertFixing(p3, false, false, true)
-  Object.preventExtensions(p3)
-  assertFixing(p3, names.length === 0, names.length === 0, false)
-  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p3).sort())
-  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
-                    Object.keys(p3).sort())
-  assertEquals(proto, Object.getPrototypeOf(p3))
-  assertEquals(77, p3.p)
-
-  var p = Proxy.create(handler, proto)
-  var o = Object.create(p)
-  assertFixing(p, false, false, true)
-  assertFixing(o, false, false, true)
-  Object.freeze(o)
-  assertFixing(p, false, false, true)
-  assertFixing(o, true, true, false)
+// TODO(neis): Reenable/adapt once proxies properly support these operations.
+//
+//  var proto = {p: 77}
+//  var assertFixing = function(o, s, f, e) {
+//    assertEquals(s, Object.isSealed(o))
+//    assertEquals(f, Object.isFrozen(o))
+//    assertEquals(e, Object.isExtensible(o))
+//  }
+//
+//  var p1 = Proxy.create(handler, proto)
+//  assertFixing(p1, false, false, true)
+//  Object.seal(p1)
+//  assertFixing(p1, true, names.length === 0, false)
+//  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p1).sort())
+//  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
+//                    Object.keys(p1).sort())
+//  assertEquals(proto, Object.getPrototypeOf(p1))
+//  assertEquals(77, p1.p)
+//  for (var n in p1) {
+//    var desc = Object.getOwnPropertyDescriptor(p1, n)
+//    if (desc !== undefined) assertFalse(desc.configurable)
+//  }
+//
+//  var p2 = Proxy.create(handler, proto)
+//  assertFixing(p2, false, false, true)
+//  Object.freeze(p2)
+//  assertFixing(p2, true, true, false)
+//  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p2).sort())
+//  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
+//                    Object.keys(p2).sort())
+//  assertEquals(proto, Object.getPrototypeOf(p2))
+//  assertEquals(77, p2.p)
+//  for (var n in p2) {
+//    var desc = Object.getOwnPropertyDescriptor(p2, n)
+//    if (desc !== undefined) assertFalse(desc.writable)
+//    if (desc !== undefined) assertFalse(desc.configurable)
+//  }
+//
+//  var p3 = Proxy.create(handler, proto)
+//  assertFixing(p3, false, false, true)
+//  Object.preventExtensions(p3)
+//  assertFixing(p3, names.length === 0, names.length === 0, false)
+//  assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p3).sort())
+//  assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
+//                    Object.keys(p3).sort())
+//  assertEquals(proto, Object.getPrototypeOf(p3))
+//  assertEquals(77, p3.p)
+//
+//  var p = Proxy.create(handler, proto)
+//  var o = Object.create(p)
+//  assertFixing(p, false, false, true)
+//  assertFixing(o, false, false, true)
+//  Object.freeze(o)
+//  assertFixing(p, false, false, true)
+//  assertFixing(o, true, true, false)
 }
 
 TestFix([], {
   fix: function() { return {} }
 })
 
 TestFix(["a", "b", "c", "3", "zz"], {
   fix: function() {
     return {
       a: {value: "a", writable: true, configurable: false, enumerable: true},
@@ skipping 15 matching lines @@
 TestFix(["b"], {
   get fix() {
     return function() {
       return {b: {configurable: true, writable: true, enumerable: true}}
     }
   }
 })
 
 
 function TestFixFunction(fix) {
-  var f1 = Proxy.createFunction({
-    fix: function() { return {} }
-  }, function() {})
-  fix(f1)
-  assertEquals(0, f1.length)
-
-  var f2 = Proxy.createFunction({
-    fix: function() { return {length: {value: 3}} }
-  }, function() {})
-  fix(f2)
-  assertEquals(3, f2.length)
-
-  var f3 = Proxy.createFunction({
-    fix: function() { return {length: {value: "huh"}} }
-  }, function() {})
-  fix(f3)
-  assertEquals(0, f1.length)
+// TODO(neis): Reenable/adapt once proxies properly support these operations.
+//
+//  var f1 = Proxy.createFunction({
+//    fix: function() { return {} }
+//  }, function() {})
+//  fix(f1)
+//  assertEquals(0, f1.length)
+//
+//  var f2 = Proxy.createFunction({
+//    fix: function() { return {length: {value: 3}} }
+//  }, function() {})
+//  fix(f2)
+//  assertEquals(3, f2.length)
+//
+//  var f3 = Proxy.createFunction({
+//    fix: function() { return {length: {value: "huh"}} }
+//  }, function() {})
+//  fix(f3)
+//  assertEquals(0, f1.length)
 }
 
 TestFixFunction(Object.seal)
 TestFixFunction(Object.freeze)
 TestFixFunction(Object.preventExtensions)
 
 
 function TestFixThrow(handler) {
   TestWithProxies(TestFixThrow2, handler)
 }
 
 function TestFixThrow2(create, handler) {
-  var p = create(handler, {})
-  assertThrows(function(){ Object.seal(p) }, "myexn")
-  assertThrows(function(){ Object.freeze(p) }, "myexn")
-  assertThrows(function(){ Object.preventExtensions(p) }, "myexn")
+// TODO(neis): Reenable/adapt once proxies properly support these operations.
+//
+//  var p = create(handler, {})
+//  assertThrows(function(){ Object.seal(p) }, "myexn")
+//  assertThrows(function(){ Object.freeze(p) }, "myexn")
+//  assertThrows(function(){ Object.preventExtensions(p) }, "myexn")
 }
 
 TestFixThrow({
   fix: function() { throw "myexn" }
 })
 
 TestFixThrow({
   fix: function() { return this.fix2() },
   fix2: function() { throw "myexn" }
 })
 
 TestFixThrow({
   get fix() { throw "myexn" }
 })
 
 TestFixThrow({
   get fix() {
     return function() { throw "myexn" }
   }
 })
 
 
 // Freeze a proxy in the middle of operations on it.
 // TODO(rossberg): actual behaviour not specified consistently at the moment,
 // just make sure that we do not crash.
 function TestReentrantFix(f) {
-  TestWithProxies(f, Object.freeze)
-  TestWithProxies(f, Object.seal)
-  TestWithProxies(f, Object.preventExtensions)
+// TODO(neis): Reenable/adapt once proxies properly support these operations.
+//
+//  TestWithProxies(f, Object.freeze)
+//  TestWithProxies(f, Object.seal)
+//  TestWithProxies(f, Object.preventExtensions)
 }
 
 TestReentrantFix(function(create, freeze) {
   var handler = {
     get get() { freeze(p); return undefined },
     fix: function() { return {} }
   }
   var p = create(handler)
   // Freeze while getting get trap.
   try { p.x } catch (e) { assertInstanceof(e, Error) }
@@ skipping 334 matching lines @@
   function f() {
     return o.x;
   }
   assertEquals(10, f());
   assertEquals(10, f());
   %OptimizeFunctionOnNextCall(f);
   assertEquals(10, f());
 }
 
 TestOptWithProxyPrototype();