[runtime] support new Proxy() instead of Proxy.create and install getPrototypeOf trap

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 17 matching lines @@
 // We change the stack size for the ARM64 simulator because at one point this
 // test enters an infinite recursion which goes through the runtime and we
 // overflow the system stack before the simulator stack.
 
 // Flags: --harmony-proxies --sim-stack-size=500 --allow-natives-syntax
 
 
 // Helper.
 
 function TestWithProxies(test, x, y, z) {
-  test(Proxy.create, x, y, z)
-  test(function(h) {return Proxy.createFunction(h, function() {})}, x, y, z)
+  test(function(handler) { return new Proxy({}, handler) }, x, y, z)
+  test(function(handler) {
+    return Proxy.createFunction(handler, function() {})
+  }, x, y, z)
 }
 
 
 
 // Getting property descriptors (Object.getOwnPropertyDescriptor).
 
 var key
 
 function TestGetOwnProperty(handler) {
   TestWithProxies(TestGetOwnProperty2, handler)
@@ skipping 24 matching lines @@
   }
 })
 
 TestGetOwnProperty({
   getOwnPropertyDescriptor: function(k) {
     key = k
     return {get value() { return 42 }, get configurable() { return true }}
   }
 })
 
-TestGetOwnProperty(Proxy.create({
+TestGetOwnProperty(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { key = k; return {value: 42, configurable: true} }
   }
 }))
 
 
 function TestGetOwnPropertyThrow(handler) {
   TestWithProxies(TestGetOwnPropertyThrow2, handler)
 }
 
@@ skipping 13 matching lines @@
   },
   getOwnPropertyDescriptor2: function(k) { throw "myexn" }
 })
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) {
     return {get value() { throw "myexn" }}
   }
 })
 
-TestGetOwnPropertyThrow(Proxy.create({
+TestGetOwnPropertyThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
 
 
 // Getters (dot, brackets).
 
 var key
@@ skipping 54 matching lines @@
     key = k;
     return {get value() { return 42 }}
   }
 })
 
 TestGet({
   get: undefined,
   getPropertyDescriptor: function(k) { key = k; return {value: 42} }
 })
 
-TestGet(Proxy.create({
+TestGet(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { key = k; return 42 }
   }
 }))
 
 
 function TestGetCall(handler) {
   TestWithProxies(TestGetCall2, handler)
 }
 
@@ skipping 76 matching lines @@
     if (k == "gg") {
       return function() { return 55 }
     } else if (k == "withargs") {
       return function(n, m) { return n + m * 2 }
     } else {
       return function() { return this.gg() }
     }
   }
 })
 
-TestGetCall(Proxy.create({
+TestGetCall(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { return function() { return 55 } }
   }
 }))
 
 
 function TestGetThrow(handler) {
   TestWithProxies(TestGetThrow2, handler)
 }
 
@@ skipping 35 matching lines @@
   getPropertyDescriptor: function(k) {
     return {get value() { throw "myexn" }}
   }
 })
 
 TestGetThrow({
   get: undefined,
   getPropertyDescriptor: function(k) { throw "myexn" }
 })
 
-TestGetThrow(Proxy.create({
+TestGetThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestGetThrow(Proxy.create({
+TestGetThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { throw "myexn" }
   }
 }))
 
 
 
 // Setters.
 
 var key
@@ skipping 83 matching lines @@
     return {set: function(v) { key = k; val = v }}
   }
 })
 
 TestSet({
   getOwnPropertyDescriptor: function(k) { return null },
   getPropertyDescriptor: function(k) { return null },
   defineProperty: function(k, desc) { key = k, val = desc.value }
 })
 
-TestSet(Proxy.create({
+TestSet(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k, v) { key = k; val = v; return true }
   }
 }))
 
 
 function TestSetThrow(handler) {
   TestWithProxies(TestSetThrow2, handler)
 }
 
@@ skipping 97 matching lines @@
     return {set: function(v) { throw "myexn" }}
   }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) { return null },
   getPropertyDescriptor: function(k) { return null },
   defineProperty: function(k, desc) { throw "myexn" }
 })
 
-TestSetThrow(Proxy.create({
+TestSetThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestSetThrow(Proxy.create({
+TestSetThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k, v) { throw "myexn" }
   }
 }))
 
 
 var rec
 var key
 var val
 
@@ skipping 222 matching lines @@
 
 TestDefine({
   defineProperty: function(k, d) { key = k; desc = d; return true }
 })
 
 TestDefine({
   defineProperty: function(k, d) { return this.defineProperty2(k, d) },
   defineProperty2: function(k, d) { key = k; desc = d; return true }
 })
 
-TestDefine(Proxy.create({
+TestDefine(new Proxy({}, {
   get: function(pr, pk) {
     return function(k, d) { key = k; desc = d; return true }
   }
 }))
 
 
 function TestDefineThrow(handler) {
   TestWithProxies(TestDefineThrow2, handler)
 }
 
@@ skipping 19 matching lines @@
 
 TestDefineThrow({
   defineProperty: function(k, d) { throw "myexn" }
 })
 
 TestDefineThrow({
   defineProperty: function(k, d) { return this.defineProperty2(k, d) },
   defineProperty2: function(k, d) { throw "myexn" }
 })
 
-TestDefineThrow(Proxy.create({
+TestDefineThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestDefineThrow(Proxy.create({
+TestDefineThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k, d) { throw "myexn" }
   }
 }))
 
 
 
 // Property deletion (delete).
 
 var key
@@ skipping 34 matching lines @@
 
 TestDelete({
   delete: function(k) { key = k; return k < "z" }
 })
 
 TestDelete({
   delete: function(k) { return this.delete2(k) },
   delete2: function(k) { key = k; return k < "z" }
 })
 
-TestDelete(Proxy.create({
+TestDelete(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { key = k; return k < "z" }
   }
 }))
 
 
 function TestDeleteThrow(handler) {
   TestWithProxies(TestDeleteThrow2, handler)
 }
 
@@ skipping 13 matching lines @@
 
 TestDeleteThrow({
   delete: function(k) { throw "myexn" }
 })
 
 TestDeleteThrow({
   delete: function(k) { return this.delete2(k) },
   delete2: function(k) { throw "myexn" }
 })
 
-TestDeleteThrow(Proxy.create({
+TestDeleteThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestDeleteThrow(Proxy.create({
+TestDeleteThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
 
 
 // Property descriptors (Object.getOwnPropertyDescriptor).
 
 function TestDescriptor(handler) {
@@ skipping 78 matching lines @@
 TestComparison(function(o1, o2) { return o1 == o2 })
 TestComparison(function(o1, o2) { return o1 === o2 })
 TestComparison(function(o1, o2) { return !(o1 != o2) })
 TestComparison(function(o1, o2) { return !(o1 !== o2) })
 
 
 
 // Type (typeof).
 
 function TestTypeof() {
-  assertEquals("object", typeof Proxy.create({}))
-  assertTrue(typeof Proxy.create({}) == "object")
-  assertTrue("object" == typeof Proxy.create({}))
+  assertEquals("object", typeof new Proxy({}, {}))
+  assertTrue(typeof new Proxy({}, {}) == "object")
+  assertTrue("object" == typeof new Proxy({}, {}))
 
   assertEquals("function", typeof Proxy.createFunction({}, function() {}))
   assertTrue(typeof Proxy.createFunction({}, function() {}) == "function")
   assertTrue("function" == typeof Proxy.createFunction({}, function() {}))
 }
 
 TestTypeof()
 
 
 
@@ skipping 71 matching lines @@
   }
 })
 
 TestIn({
   has: undefined,
   getPropertyDescriptor: function(k) {
     key = k; return k < "z" ? {value: 42} : void 0
   }
 })
 
-TestIn(Proxy.create({
+TestIn(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { key = k; return k < "z" }
   }
 }))
 
 
 function TestInThrow(handler) {
   TestWithProxies(TestInThrow2, handler)
 }
 
@@ skipping 24 matching lines @@
 TestInThrow({
   getPropertyDescriptor: function(k) { return this.getPropertyDescriptor2(k) },
   getPropertyDescriptor2: function(k) { throw "myexn" }
 })
 
 TestInThrow({
   has: undefined,
   getPropertyDescriptor: function(k) { throw "myexn" }
 })
 
-TestInThrow(Proxy.create({
+TestInThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestInThrow(Proxy.create({
+TestInThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
 
 function TestInForDerived(handler) {
   TestWithProxies(TestInForDerived2, handler)
 }
 
@@ skipping 74 matching lines @@
 })
 
 TestInForDerived({
   getOwnPropertyDescriptor: function(k) {
     key = k;
     return k < "z" ? {get value() { return 42 }, configurable: true} : void 0
   }
 })
 */
 
-TestInForDerived(Proxy.create({
+TestInForDerived(new Proxy({}, {
   get: function(pr, pk) {
     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 p = new Proxy({}, handler)
   var o = Object.create(p, {b: {value: 0}})
   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 }, "")
 }
 
 function TestDescriptorGetOrder2(f, access) {
   descget = ""
   assertTrue(f("a"))
   assertEquals(access, descget)
   descget = ""
   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({
+    return new Proxy({}, {
       get: function(r, attr) {
         descget += attr[0].toUpperCase()
         return true
       },
       has: function(attr) {
         descget += attr[0]
         switch (attr) {
           case "writable":
           case "enumerable":
           case "configurable":
@@ skipping 60 matching lines @@
   }
 })
 
 TestHasOwn({
   hasOwn: undefined,
   getOwnPropertyDescriptor: function(k) {
     key = k; return k < "z" ? {value: 42} : void 0
   }
 })
 
-TestHasOwn(Proxy.create({
+TestHasOwn(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { key = k; return k < "z" }
   }
 }))
 
 
 function TestHasOwnThrow(handler) {
   TestWithProxies(TestHasOwnThrow2, handler)
 }
 
@@ skipping 23 matching lines @@
     return this.getOwnPropertyDescriptor2(k)
   },
   getOwnPropertyDescriptor2: function(k) { throw "myexn" }
 })
 
 TestHasOwnThrow({
   hasOwn: undefined,
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
-TestHasOwnThrow(Proxy.create({
+TestHasOwnThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestHasOwnThrow(Proxy.create({
+TestHasOwnThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
 
 
 // Instanceof (instanceof)
 
 function TestProxyInstanceof() {
   var o1 = {}
-  var p1 = Proxy.create({})
-  var p2 = Proxy.create({}, o1)
-  var p3 = Proxy.create({}, p2)
+  var p1 = new Proxy({}, {})
+  var p2 = new Proxy(o1, {})
+  var p3 = new Proxy(p2, {})
   var o2 = Object.create(p2)
 
   var f0 = function() {}
   f0.prototype = o1
   var f1 = function() {}
   f1.prototype = p1
   var f2 = function() {}
   f2.prototype = p2
   var f3 = function() {}
   f3.prototype = o2
 
   assertTrue(o1 instanceof Object)
   assertFalse(o1 instanceof f0)
   assertFalse(o1 instanceof f1)
   assertFalse(o1 instanceof f2)
-  assertFalse(o1 instanceof f3)
-  assertFalse(p1 instanceof Object)
+  assertFalse(o1 instanceof f3);
+  assertTrue(p1 instanceof Object)
   assertFalse(p1 instanceof f0)
   assertFalse(p1 instanceof f1)
   assertFalse(p1 instanceof f2)
   assertFalse(p1 instanceof f3)
   assertTrue(p2 instanceof Object)
   assertTrue(p2 instanceof f0)
   assertFalse(p2 instanceof f1)
   assertFalse(p2 instanceof f2)
   assertFalse(p2 instanceof f3)
   assertTrue(p3 instanceof Object)
@@ skipping 74 matching lines @@
   assertFalse(f instanceof ff)
 }
 
 TestInstanceofProxy()
 
 
 
 // Prototype (Object.getPrototypeOf, Object.prototype.isPrototypeOf).
 
 function TestPrototype() {
-  var o1 = {}
-  var p1 = Proxy.create({})
-  var p2 = Proxy.create({}, o1)
-  var p3 = Proxy.create({}, p2)
-  var p4 = Proxy.create({}, null)
+  var o1 = {o1:true}
+  var p1 = new Proxy({p1:true}, {handler_p1:true})
+  var p2 = new Proxy(o1, {handler_p2:true})
+  var p3 = new Proxy(p2, {handler_p3:true})
+  var p4 = new Proxy({p4:true}, {handler_p4:true})
   var o2 = Object.create(p3)
 
   assertSame(Object.getPrototypeOf(o1), Object.prototype)
-  assertSame(Object.getPrototypeOf(p1), null)
-  assertSame(Object.getPrototypeOf(p2), o1)
-  assertSame(Object.getPrototypeOf(p3), p2)
-  assertSame(Object.getPrototypeOf(p4), null)
+  assertSame(Object.getPrototypeOf(p1), Object.prototype)
+  assertSame(Object.getPrototypeOf(p2), Object.prototype)
+  assertSame(Object.getPrototypeOf(p3), Object.prototype)
+  assertSame(Object.getPrototypeOf(p4), Object.prototype)
   assertSame(Object.getPrototypeOf(o2), p3)
 
   assertTrue(Object.prototype.isPrototypeOf(o1))
-  assertFalse(Object.prototype.isPrototypeOf(p1))
+  assertTrue(Object.prototype.isPrototypeOf(p1))
   assertTrue(Object.prototype.isPrototypeOf(p2))
   assertTrue(Object.prototype.isPrototypeOf(p3))
-  assertFalse(Object.prototype.isPrototypeOf(p4))
+  assertTrue(Object.prototype.isPrototypeOf(p4))
   assertTrue(Object.prototype.isPrototypeOf(o2))
   assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, o1))
-  assertFalse(Object.prototype.isPrototypeOf.call(Object.prototype, p1))
+  assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, p1))
   assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, p2))
   assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, p3))
-  assertFalse(Object.prototype.isPrototypeOf.call(Object.prototype, p4))
+  assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, p4))
   assertTrue(Object.prototype.isPrototypeOf.call(Object.prototype, o2))
   assertFalse(Object.prototype.isPrototypeOf.call(o1, o1))
   assertFalse(Object.prototype.isPrototypeOf.call(o1, p1))
   assertTrue(Object.prototype.isPrototypeOf.call(o1, p2))
   assertTrue(Object.prototype.isPrototypeOf.call(o1, p3))
   assertFalse(Object.prototype.isPrototypeOf.call(o1, p4))
   assertTrue(Object.prototype.isPrototypeOf.call(o1, o2))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, p1))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, o1))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, p2))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, p3))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, p4))
   assertFalse(Object.prototype.isPrototypeOf.call(p1, o2))
   assertFalse(Object.prototype.isPrototypeOf.call(p2, p1))
   assertFalse(Object.prototype.isPrototypeOf.call(p2, p2))
   assertTrue(Object.prototype.isPrototypeOf.call(p2, p3))
   assertFalse(Object.prototype.isPrototypeOf.call(p2, p4))
   assertTrue(Object.prototype.isPrototypeOf.call(p2, o2))
   assertFalse(Object.prototype.isPrototypeOf.call(p3, p2))
   assertTrue(Object.prototype.isPrototypeOf.call(p3, o2))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, o1))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, p1))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, p2))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, p3))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, p4))
   assertFalse(Object.prototype.isPrototypeOf.call(o2, o2))
 
-  var f = Proxy.createFunction({}, function() {})
-  assertSame(Object.getPrototypeOf(f), Function.prototype)
-  assertTrue(Object.prototype.isPrototypeOf(f))
-  assertTrue(Object.prototype.isPrototypeOf.call(Function.prototype, f))
+  // var f = Proxy.createFunction({}, function() {})

[Jakob Kummerow, 2015/11/12 12:04:24]

how about adding a TODO so this shows up when grepping?

+  // assertSame(Object.getPrototypeOf(f), Function.prototype)
+  // assertTrue(Object.prototype.isPrototypeOf(f))
+  // assertTrue(Object.prototype.isPrototypeOf.call(Function.prototype, f))
 }
 
 TestPrototype()
 
 
 
 // Property names (Object.getOwnPropertyNames, Object.keys).
 
 function TestPropertyNames(names, handler) {
   TestWithProxies(TestPropertyNames2, handler, names)
@@ skipping 164 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 target = {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)
+  var p1 = new Proxy(target, handler)
   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(target, 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)
+  var p2 = new Proxy(target, handler)
   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(target, 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)
+  var p3 = new Proxy(target, handler)
   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(target, Object.getPrototypeOf(p3))
   assertEquals(77, p3.p)
 
-  var p = Proxy.create(handler, proto)
+  var p = new Proxy(target, handler)
   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 {} }
@@ skipping 213 matching lines @@
 
 
 
 // String conversion (Object.prototype.toString,
 //                    Object.prototype.toLocaleString,
 //                    Function.prototype.toString)
 
 var key
 
 function TestToString(handler) {
-  var p = Proxy.create(handler)
+  var p = new Proxy({}, handler)
   key = ""
   assertEquals("[object Object]", Object.prototype.toString.call(p))
   assertEquals("", key)
   assertEquals("my_proxy", Object.prototype.toLocaleString.call(p))
   assertEquals("toString", key)
 
   var f = Proxy.createFunction(handler, function() {})
   key = ""
   assertEquals("[object Function]", Object.prototype.toString.call(f))
   assertEquals("", key)
@@ skipping 11 matching lines @@
 
 TestToString({
   get: function(r, k) { key = k; return function() { return "my_proxy" } }
 })
 
 TestToString({
   get: function(r, k) { return this.get2(r, k) },
   get2: function(r, k) { key = k; return function() { return "my_proxy" } }
 })
 
-TestToString(Proxy.create({
+TestToString(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { key = k; return function() { return "my_proxy" } }
   }
 }))
 
 
 function TestToStringThrow(handler) {
-  var p = Proxy.create(handler)
+  var p = new Proxy({}, handler)
   assertEquals("[object Object]", Object.prototype.toString.call(p))
   assertThrows(function(){ Object.prototype.toLocaleString.call(p) }, "myexn")
 
   var f = Proxy.createFunction(handler, function() {})
   assertEquals("[object Function]", Object.prototype.toString.call(f))
   assertThrows(function(){ Object.prototype.toLocaleString.call(f) }, "myexn")
 
   var o = Object.create(p)
   assertEquals("[object Object]", Object.prototype.toString.call(o))
   assertThrows(function(){ Object.prototype.toLocaleString.call(o) }, "myexn")
 }
 
 TestToStringThrow({
   get: function(r, k) { throw "myexn" }
 })
 
 TestToStringThrow({
   get: function(r, k) { return function() { throw "myexn" } }
 })
 
 TestToStringThrow({
   get: function(r, k) { return this.get2(r, k) },
   get2: function(r, k) { throw "myexn" }
 })
 
-TestToStringThrow(Proxy.create({
+TestToStringThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestToStringThrow(Proxy.create({
+TestToStringThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { throw "myexn" }
   }
 }))
 
 
 
 // Value conversion (Object.prototype.toValue)
 
 function TestValueOf(handler) {
@@ skipping 46 matching lines @@
     key = k; return {enumerable: k < "z", configurable: true}
   },
 })
 
 TestIsEnumerable({
   getOwnPropertyDescriptor: function(k) {
     key = k; return {get enumerable() { return k < "z" }, configurable: true}
   },
 })
 
-TestIsEnumerable(Proxy.create({
+TestIsEnumerable(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) {
       key = k; return {enumerable: k < "z", configurable: true}
     }
   }
 }))
 
 
 function TestIsEnumerableThrow(handler) {
   TestWithProxies(TestIsEnumerableThrow2, handler)
@@ skipping 17 matching lines @@
   },
   getOwnPropertyDescriptor2: function(k) { throw "myexn" }
 })
 
 TestIsEnumerableThrow({
   getOwnPropertyDescriptor: function(k) {
     return {get enumerable() { throw "myexn" }, configurable: true}
   },
 })
 
-TestIsEnumerableThrow(Proxy.create({
+TestIsEnumerableThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
-TestIsEnumerableThrow(Proxy.create({
+TestIsEnumerableThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
 
 
 // Constructor functions with proxy prototypes.
 
 function TestConstructorWithProxyPrototype() {
@@ skipping 11 matching lines @@
 TestConstructorWithProxyPrototype();
 
 function TestOptWithProxyPrototype() {
   var handler = {
     getPropertyDescriptor: function(k) {
       return {value: 10, configurable: true, enumerable: true, writable: true};
     }
   };
 
   function C() {};
-  C.prototype = Proxy.create(handler);
+  C.prototype = new Proxy({}, handler);
   var o = new C();
 
   function f() {
     return o.x;
   }
   assertEquals(10, f());
   assertEquals(10, f());
   %OptimizeFunctionOnNextCall(f);
   assertEquals(10, f());
 }
 
 TestOptWithProxyPrototype();