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

src/js/proxy.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 // ----------------------------------------------------------------------------
 // Imports
-
+var GlobalProxy = global.Proxy;
 var GlobalFunction = global.Function;
 var GlobalObject = global.Object;
 var MakeTypeError;
 var ToNameArray;
 
 utils.Import(function(from) {
   MakeTypeError = from.MakeTypeError;
   ToNameArray = from.ToNameArray;
 });
 
 //----------------------------------------------------------------------------
 
-function ProxyCreate(handler, proto) {
-  if (!IS_SPEC_OBJECT(handler))
-    throw MakeTypeError(kProxyHandlerNonObject, "create")
-  if (IS_UNDEFINED(proto))
-    proto = null
-  else if (!(IS_SPEC_OBJECT(proto) || IS_NULL(proto)))
-    throw MakeTypeError(kProxyProtoNonObject)
-  return %CreateJSProxy(handler, proto)
+function ProxyCreate(target, handler) {
+  if (!%_IsConstructCall()) {
+    throw MakeTypeError(kConstructorNotFunction, "Proxy");
+  } else if (!IS_SPEC_OBJECT(target)) {
+    throw MakeTypeError(kProxyTargetNonObject, "create")
+  }
+  if (IS_UNDEFINED(handler)) {
+    handler = null
+  } else if (!(IS_SPEC_OBJECT(handler) || IS_NULL(handler))) {
+    throw MakeTypeError(kProxyHandlerNonObject)
+  }
+  return %CreateJSProxy(target, handler)
 }
 
 function ProxyCreateFunction(handler, callTrap, constructTrap) {
   if (!IS_SPEC_OBJECT(handler))
-    throw MakeTypeError(kProxyHandlerNonObject, "createFunction")
+    throw MakeTypeError(kProxyTargetNonObject, "createFunction")

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

This is surprising

[Camillo Bruni, 2015/11/12 20:20:55]

blind rename :), reverting.

   if (!IS_CALLABLE(callTrap))
     throw MakeTypeError(kProxyTrapFunctionExpected, "call")
   if (IS_UNDEFINED(constructTrap)) {
     constructTrap = DerivedConstructTrap(callTrap)
   } else if (IS_CALLABLE(constructTrap)) {
     // Make sure the trap receives 'undefined' as this.
     var construct = constructTrap
     constructTrap = function() {
       return %Apply(construct, UNDEFINED, arguments, 0, %_ArgumentsLength());
     }
@@ skipping 126 matching lines @@
 function ProxyEnumerate(proxy) {
   var handler = %GetHandler(proxy)
   if (IS_UNDEFINED(handler.enumerate)) {
     return %Apply(DerivedEnumerateTrap, handler, [], 0, 0)
   } else {
     return ToNameArray(handler.enumerate(), "enumerate", false)
   }
 }
 
 //-------------------------------------------------------------------
+%SetCode(GlobalProxy, ProxyCreate);
+%FunctionSetPrototype(GlobalProxy, new GlobalObject());
 
-var Proxy = new GlobalObject();
-%AddNamedProperty(global, "Proxy", Proxy, DONT_ENUM);
+// //Set up non-enumerable properties of the Proxy object.
+utils.InstallFunctions(GlobalProxy, DONT_ENUM, [
+  "createFunction", ProxyCreateFunction
+]);
 
-//Set up non-enumerable properties of the Proxy object.
-utils.InstallFunctions(Proxy, DONT_ENUM, [
-  "create", ProxyCreate,
-  "createFunction", ProxyCreateFunction
-])
-
+%AddNamedProperty(GlobalProxy.prototype, "constructor", GlobalProxy, DONT_ENUM);
 // -------------------------------------------------------------------
 // Exports
 
 utils.Export(function(to) {
   to.ProxyDelegateCallAndConstruct = DelegateCallAndConstruct;
   to.ProxyDerivedHasOwnTrap = DerivedHasOwnTrap;
   to.ProxyDerivedKeysTrap = DerivedKeysTrap;
 });
 
 %InstallToContext([
   "derived_get_trap", DerivedGetTrap,
   "derived_has_trap", DerivedHasTrap,
   "derived_set_trap", DerivedSetTrap,
   "proxy_enumerate", ProxyEnumerate,
 ]);
 
 })