Make integer indexed properties ("elements") work for proxies.

test/mjsunit/harmony/proxies.js

 // Copyright 2008 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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --harmony-proxies
 
 
-// TODO(rossberg): integer-index properties not implemented properly.
 // TODO(rossberg): for-in not implemented on proxies.
 
 
 // Helper.
 
 function TestWithProxies(test, handler) {
   test(handler, Proxy.create)
   test(handler, function(h) {return Proxy.createFunction(h, function() {})})
 }
 
 
 
 // Getting property descriptors (Object.getOwnPropertyDescriptor).
 
 var key
 
 function TestGetOwnProperty(handler) {
   TestWithProxies(TestGetOwnProperty2, handler)
 }
 
 function TestGetOwnProperty2(handler, create) {
   var p = create(handler)
   assertEquals(42, Object.getOwnPropertyDescriptor(p, "a").value)
   assertEquals("a", key)
+  assertEquals(42, Object.getOwnPropertyDescriptor(p, 99).value)
+  assertEquals("99", key)
 }
 
 TestGetOwnProperty({
   getOwnPropertyDescriptor: function(k) {
     key = k
     return {value: 42, configurable: true}
   }
 })
 
 TestGetOwnProperty({
@@ skipping 20 matching lines @@
 }))
 
 
 function TestGetOwnPropertyThrow(handler) {
   TestWithProxies(TestGetOwnPropertyThrow2, handler)
 }
 
 function TestGetOwnPropertyThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ Object.getOwnPropertyDescriptor(p, "a") }, "myexn")
+  assertThrows(function(){ Object.getOwnPropertyDescriptor(p, 77) }, "myexn")
 }
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) {
     return this.getPropertyDescriptor2(k)
   },
@@ skipping 83 matching lines @@
   TestWithProxies(TestGetCall2, handler)
 }
 
 function TestGetCall2(handler, create) {
   var p = create(handler)
   assertEquals(55, p.f())
   assertEquals(55, p["f"]())
   assertEquals(55, p.f("unused", "arguments"))
   assertEquals(55, p.f.call(p))
   assertEquals(55, p["f"].call(p))
+  assertEquals(55, p[101].call(p))
   assertEquals(55, p.withargs(45, 5))
   assertEquals(55, p.withargs.call(p, 11, 22))
   assertEquals("6655", "66" + p)  // calls p.toString
 
   var o = Object.create(p, {g: {value: function(x) { return x + 88 }}})
   assertEquals(55, o.f())
   assertEquals(55, o["f"]())
   assertEquals(55, o.f("unused", "arguments"))
   assertEquals(55, o.f.call(o))
   assertEquals(55, o.f.call(p))
   assertEquals(55, o["f"].call(p))
+  assertEquals(55, o[101].call(p))
   assertEquals(55, o.withargs(45, 5))
   assertEquals(55, o.withargs.call(p, 11, 22))
   assertEquals(90, o.g(2))
   assertEquals(91, o.g.call(o, 3))
   assertEquals(92, o.g.call(p, 4))
   assertEquals("6655", "66" + o)  // calls o.toString
 }
 
 TestGetCall({
   get: function(r, k) { return function() { return 55 } }
@@ skipping 50 matching lines @@
 
 
 function TestGetThrow(handler) {
   TestWithProxies(TestGetThrow2, handler)
 }
 
 function TestGetThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ p.a }, "myexn")
   assertThrows(function(){ p["b"] }, "myexn")
+  assertThrows(function(){ p[3] }, "myexn")
 
-  var o = Object.create(p, {x: {value: 88}})
+  var o = Object.create(p, {x: {value: 88}, '4': {value: 89}})
   assertThrows(function(){ o.a }, "myexn")
   assertThrows(function(){ o["b"] }, "myexn")
+  assertThrows(function(){ o[3] }, "myexn")
   assertEquals(88, o.x)
   assertEquals(88, o["x"])
+  assertEquals(89, o[4])
 }
 
 TestGetThrow({
   get: function(r, k) { throw "myexn" }
 })
 
 TestGetThrow({
   get: function(r, k) { return this.get2(r, k) },
   get2: function(r, k) { throw "myexn" }
 })
@@ skipping 40 matching lines @@
 }
 
 function TestSet2(handler, create) {
   var p = create(handler)
   assertEquals(42, p.a = 42)
   assertEquals("a", key)
   assertEquals(42, val)
   assertEquals(43, p["b"] = 43)
   assertEquals("b", key)
   assertEquals(43, val)
+  assertEquals(44, p[77] = 44)
+  assertEquals("77", key)
+  assertEquals(44, val)
 }
 
 TestSet({
   set: function(r, k, v) { key = k; val = v; return true },
 })
 
 TestSet({
   set: function(r, k, v) { return this.set2(r, k, v) },
   set2: function(r, k, v) { key = k; val = v; return true }
 })
@@ skipping 60 matching lines @@
 
 
 function TestSetThrow(handler, create) {
   TestWithProxies(TestSetThrow2, handler)
 }
 
 function TestSetThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ p.a = 42 }, "myexn")
   assertThrows(function(){ p["b"] = 42 }, "myexn")
+  assertThrows(function(){ p[22] = 42 }, "myexn")
 }
 
 TestSetThrow({
   set: function(r, k, v) { throw "myexn" }
 })
 
 TestSetThrow({
   set: function(r, k, v) { return this.set2(r, k, v) },
   set2: function(r, k, v) { throw "myexn" }
 })
@@ skipping 100 matching lines @@
 
 var key
 var val
 
 function TestSetForDerived(handler, create) {
   TestWithProxies(TestSetForDerived2, handler)
 }
 
 function TestSetForDerived2(handler, create) {
   var p = create(handler)
-  var o = Object.create(p, {x: {value: 88, writable: true}})
+  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)
 
   assertEquals(46, o.p_setter = 46)
   assertEquals("p_setter", key)
@@ skipping 60 matching lines @@
   assertEquals(2, Object.getOwnPropertyNames(desc).length)
   assertEquals(45, desc.value)
   assertEquals(false, desc.writable)
 
   assertEquals(p, Object.defineProperty(p, "c", {value: 46, enumerable: false}))
   assertEquals("c", key)
   assertEquals(2, Object.getOwnPropertyNames(desc).length)
   assertEquals(46, desc.value)
   assertEquals(false, desc.enumerable)
 
+  assertEquals(p, Object.defineProperty(p, 101, {value: 47, enumerable: false}))
+  assertEquals("101", key)
+  assertEquals(2, Object.getOwnPropertyNames(desc).length)
+  assertEquals(47, desc.value)
+  assertEquals(false, desc.enumerable)
+
   var attributes = {configurable: true, mine: 66, minetoo: 23}
   assertEquals(p, Object.defineProperty(p, "d", attributes))
   assertEquals("d", key)
   // Modifying the attributes object after the fact should have no effect.
   attributes.configurable = false
   attributes.mine = 77
   delete attributes.minetoo
   assertEquals(3, Object.getOwnPropertyNames(desc).length)
   assertEquals(true, desc.configurable)
   assertEquals(66, desc.mine)
@@ skipping 14 matching lines @@
 //    getOwnPropertyNames: function() { return ["value"] }
 //  })
 //  assertEquals(1, Object.getOwnPropertyNames(d).length)
 //  assertEquals(77, d.value)
 //  assertEquals(p, Object.defineProperty(p, "p", d))
 //  assertEquals("p", key)
 //  assertEquals(1, Object.getOwnPropertyNames(desc).length)
 //  assertEquals(77, desc.value)
 
   var props = {
-    'bla': {},
+    '11': {},
     blub: {get: function() { return true }},
     '': {get value() { return 20 }},
     last: {value: 21, configurable: true, mine: "eyes"}
   }
   Object.defineProperty(props, "hidden", {value: "hidden", enumerable: false})
   assertEquals(p, Object.defineProperties(p, props))
   assertEquals("last", key)
   assertEquals(2, Object.getOwnPropertyNames(desc).length)
   assertEquals(21, desc.value)
   assertEquals(true, desc.configurable)
@@ skipping 19 matching lines @@
 }))
 
 
 function TestDefineThrow(handler) {
   TestWithProxies(TestDefineThrow2, handler)
 }
 
 function TestDefineThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ Object.defineProperty(p, "a", {value: 44})}, "myexn")
+  assertThrows(function(){ Object.defineProperty(p, 0, {value: 44})}, "myexn")
 
 // TODO(rossberg): These tests require for-in on proxies.
 //  var d1 = create({
 //    get: function(r, k) { throw "myexn" },
 //    getOwnPropertyNames: function() { return ["value"] }
 //  })
 //  assertThrows(function(){ Object.defineProperty(p, "p", d1) }, "myexn")
 //  var d2 = create({
 //    get: function(r, k) { return 77 },
 //    getOwnPropertyNames: function() { throw "myexn" }
@@ skipping 32 matching lines @@
 function TestDelete(handler) {
   TestWithProxies(TestDelete2, handler)
 }
 
 function TestDelete2(handler, create) {
   var p = create(handler)
   assertEquals(true, delete p.a)
   assertEquals("a", key)
   assertEquals(true, delete p["b"])
   assertEquals("b", key)
+  assertEquals(true, delete p[1])
+  assertEquals("1", key)
 
   assertEquals(false, delete p.z1)
   assertEquals("z1", key)
   assertEquals(false, delete p["z2"])
   assertEquals("z2", key);
 
   (function() {
     "use strict"
     assertEquals(true, delete p.c)
     assertEquals("c", key)
     assertEquals(true, delete p["d"])
     assertEquals("d", key)
+    assertEquals(true, delete p[2])
+    assertEquals("2", key)
 
     assertThrows(function(){ delete p.z3 }, TypeError)
     assertEquals("z3", key)
     assertThrows(function(){ delete p["z4"] }, TypeError)
     assertEquals("z4", key)
   })()
 }
 
 TestDelete({
   delete: function(k) { key = k; return k < "z" }
@@ skipping 12 matching lines @@
 
 
 function TestDeleteThrow(handler) {
   TestWithProxies(TestDeleteThrow2, handler)
 }
 
 function TestDeleteThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ delete p.a }, "myexn")
   assertThrows(function(){ delete p["b"] }, "myexn");
+  assertThrows(function(){ delete p[3] }, "myexn");
 
   (function() {
     "use strict"
     assertThrows(function(){ delete p.c }, "myexn")
     assertThrows(function(){ delete p["d"] }, "myexn")
+    assertThrows(function(){ delete p[4] }, "myexn");
   })()
 }
 
 TestDeleteThrow({
   delete: function(k) { throw "myexn" }
 })
 
 TestDeleteThrow({
   delete: function(k) { return this.delete2(k) },
   delete2: function(k) { throw "myexn" }
@@ skipping 202 matching lines @@
 }))
 
 
 function TestInThrow(handler) {
   TestWithProxies(TestInThrow2, handler)
 }
 
 function TestInThrow2(handler, create) {
   var p = create(handler)
   assertThrows(function(){ return "a" in o }, "myexn")
+  assertThrows(function(){ return 99 in o }, "myexn")
   assertThrows(function(){ return !("a" in o) }, "myexn")
   assertThrows(function(){ return ("a" in o) ? 2 : 3 }, "myexn")
   assertThrows(function(){ if ("b" in o) {} }, "myexn")
   assertThrows(function(){ if (!("b" in o)) {} }, "myexn")
   assertThrows(function(){ if ("zzz" in o) {} }, "myexn")
 }
 
 TestInThrow({
   has: function(k) { throw "myexn" }
 })
@@ skipping 30 matching lines @@
 
 function TestInForDerived(handler) {
   TestWithProxies(TestInForDerived2, handler)
 }
 
 function TestInForDerived2(handler, create) {
   var p = create(handler)
   var o = Object.create(p)
   assertTrue("a" in o)
   assertEquals("a", key)
-// TODO(rossberg): integer indexes not correctly implemeted yet
-//  assertTrue(99 in o)
-//  assertEquals("99", key)
+  assertTrue(99 in o)
+  assertEquals("99", key)
   assertFalse("z" in o)
   assertEquals("z", key)
 
   assertEquals(2, ("a" in o) ? 2 : 0)
   assertEquals(0, !("a" in o) ? 2 : 0)
   assertEquals(0, ("zzz" in o) ? 2 : 0)
   assertEquals(2, !("zzz" in o) ? 2 : 0)
 
   if ("b" in o) {
   } else {
@@ skipping 69 matching lines @@
 
 
 
 // Property descriptor conversion.
 
 var descget
 
 function TestDescriptorGetOrder(handler) {
   var p = Proxy.create(handler)
   var o = Object.create(p, {b: {value: 0}})
-  TestDescriptorGetOrder2(function(n) { p[n] }, "vV")
-  TestDescriptorGetOrder2(function(n) { n in p }, "")
-  TestDescriptorGetOrder2(function(n) { o[n] }, "vV")
-  TestDescriptorGetOrder2(function(n) { n in o }, "eEcCvVwWgs")
+  TestDescriptorGetOrder2(function(n) { return p[n] }, "vV")
+  TestDescriptorGetOrder2(function(n) { return n in p }, "")
+  TestDescriptorGetOrder2(function(n) { return o[n] }, "vV")
+  TestDescriptorGetOrder2(function(n) { return n in o }, "eEcCvVwWgs")
 }
 
 function TestDescriptorGetOrder2(f, access) {
   descget = ""
-  f("a")
+  assertTrue(f("a"))
   assertEquals(access, descget)
-// TODO(rossberg): integer indexes not correctly implemented yet.
-//  descget = ""
-//  f(99)
-//  assertEquals(access, descget)
   descget = ""
-  f("z")
+  assertTrue(f(99))
+  assertEquals(access, descget)
+  descget = ""
+  assertFalse(!!f("z"))
   assertEquals("", descget)
 }
 
 TestDescriptorGetOrder({
   getPropertyDescriptor: function(k) {
     if (k >= "z") return void 0
     // Return a proxy as property descriptor, so that we can log accesses.
     return Proxy.create({
       get: function(r, attr) {
         descget += attr[0].toUpperCase()
@@ skipping 475 matching lines @@
   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", "d", "zz"], {
+TestFix(["a", "b", "c", "3", "zz"], {
   fix: function() {
     return {
       a: {value: "a", writable: true, configurable: false, enumerable: true},
       b: {value: 33, writable: false, configurable: false, enumerable: true},
       c: {value: 0, writable: true, configurable: true, enumerable: true},
-      d: {value: true, writable: false, configurable: true, enumerable: true},
+      '3': {value: true, writable: false, configurable: true, enumerable: true},
       zz: {value: 0, enumerable: false}
     }
   }
 })
 
 TestFix(["a"], {
   fix: function() { return this.fix2() },
   fix2: function() {
     return {a: {value: 4, writable: true, configurable: true, enumerable: true}}
   }
@@ skipping 481 matching lines @@
 
 function TestConstructThrow2(f) {
   assertThrows(function(){ new f(11) }, "myexn")
   Object.freeze(f)
   assertThrows(function(){ new f(11) }, "myexn")
 }
 
 TestConstructThrow(function() { throw "myexn" })
 TestConstructThrow(Proxy.createFunction({}, function() { throw "myexn" }))
 TestConstructThrow(CreateFrozen({}, function() { throw "myexn" }))