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)
   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
 
+  assertThrows(function(){ o.p_nonconf = 53 }, TypeError)
+  assertEquals("p_nonconf", key)
+
   assertThrows(function(){ o.p_throw = 51 }, "myexn")
   assertEquals("p_throw", key)
 
   assertThrows(function(){ o.p_setterthrow = 52 }, "myexn")
   assertEquals("p_setterthrow", key)
 }
 
 TestSetForDerived({
   getOwnPropertyDescriptor: function(k) {
     key = k;
     switch (k) {
-      case "p_writable": return {writable: true}
-      case "p_nonwritable": return {writable: false}
-      case "p_setter":return {set: function(x) { val = x }}
-      case "p_nosetter": return {get: function() { return 1 }}
+      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_throw": throw "myexn"
       case "p_setterthrow": return {set: function(x) { throw "myexn" }}
       default: return undefined
     }
   }
 })
 
 
 // TODO(rossberg): TestSetReject, returning false
 // TODO(rossberg): TestGetProperty, TestSetProperty
@@ skipping 21 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 28 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 13 matching lines @@
 
   if (!("zzz" in o)) {
   } else {
     assertTrue(false)
   }
   assertEquals("zzz", key)
 }
 
 TestInForDerived({
   getPropertyDescriptor: function(k) {
-    key = k; return k < "z" ? {value: 42} : void 0
+    key = k; return k < "z" ? {value: 42, configurable: true} : void 0
   }
 })
 
 TestInForDerived({
   getPropertyDescriptor: function(k) { return this.getPropertyDescriptor2(k) },
   getPropertyDescriptor2: function(k) {
-    key = k; return k < "z" ? {value: 42} : void 0
+    key = k; return k < "z" ? {value: 42, configurable: true} : void 0
   }
 })
 
 TestInForDerived({
   getPropertyDescriptor: function(k) {
-    key = k; return k < "z" ? {get value() { return 42 }} : void 0
+    key = k;
+    return k < "z" ? {get value() { return 42 }, configurable: true} : void 0
   }
 })
 
 /* TODO(rossberg): this will work once we implement the newest proposal
  * regarding default traps for getPropertyDescriptor.
 TestInForDerived({
   getOwnPropertyDescriptor: function(k) {
-    key = k; return k < "z" ? {value: 42} : void 0
+    key = k; return k < "z" ? {value: 42, configurable: true} : void 0
   }
 })
 
 TestInForDerived({
   getOwnPropertyDescriptor: function(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
   getOwnPropertyDescriptor2: function(k) {
-    key = k; return k < "z" ? {value: 42} : void 0
+    key = k; return k < "z" ? {value: 42, configurable: true} : void 0
   }
 })
 
 TestInForDerived({
   getOwnPropertyDescriptor: function(k) {
-    key = k; return k < "z" ? {get value() { return 42 }} : void 0
+    key = k;
+    return k < "z" ? {get value() { return 42 }, configurable: true} : void 0
   }
 })
 */
 
 TestInForDerived(Proxy.create({
   get: function(pr, pk) {
-    return function(k) { key = k; return k < "z" ? {value: 42} : void 0 }
+    return function(k) {
+      key = k; return k < "z" ? {value: 42, configurable: true} : void 0
+    }
   }
 }))
 
 
 
 // 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" }))