Revert of Hook up more import/exports in natives.

src/v8natives.js

 // Copyright 2012 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.
 
+var $delete;
 var $functionSourceString;
+var $getIterator;
+var $getMethod;
 var $globalEval;
+var $installConstants;
+var $installFunctions;
+var $installGetter;
+var $isFinite;
+var $isNaN;
+var $newFunctionString;
+var $numberIsNaN;
+var $objectDefineProperties;
+var $objectDefineProperty;
+var $objectFreeze;
 var $objectGetOwnPropertyDescriptor;
+var $objectGetOwnPropertyKeys;
+var $objectHasOwnProperty;
+var $objectIsFrozen;
+var $objectIsSealed;
+var $objectLookupGetter;
+var $objectLookupSetter;
+var $objectToString;
+var $overrideFunction;
+var $ownPropertyKeys;
+var $setFunctionName;
+var $setUpLockedPrototype;
 var $toCompletePropertyDescriptor;
+var $toNameArray;
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // ----------------------------------------------------------------------------
 // Imports
 
 var GlobalArray = global.Array;
 var GlobalBoolean = global.Boolean;
 var GlobalFunction = global.Function;
 var GlobalNumber = global.Number;
 var GlobalObject = global.Object;
 var InternalArray = utils.InternalArray;
 
 var MathAbs;
-var ProxyDelegateCallAndConstruct;
-var ProxyDerivedHasOwnTrap;
-var ProxyDerivedKeysTrap;
 var StringIndexOf;
 
 utils.Import(function(from) {
   MathAbs = from.MathAbs;
   StringIndexOf = from.StringIndexOf;
 });
 
-utils.ImportFromExperimental(function(from) {
-  ProxyDelegateCallAndConstruct = from.ProxyDelegateCallAndConstruct;
-  ProxyDerivedHasOwnTrap = from.ProxyDerivedHasOwnTrap;
-  ProxyDerivedKeysTrap = from.ProxyDerivedKeysTrap;
-});
-
 // ----------------------------------------------------------------------------
 
+// ES6 - 9.2.11 SetFunctionName
+function SetFunctionName(f, name, prefix) {
+  if (IS_SYMBOL(name)) {
+    name = "[" + %SymbolDescription(name) + "]";
+  }
+  if (IS_UNDEFINED(prefix)) {
+    %FunctionSetName(f, name);
+  } else {
+    %FunctionSetName(f, prefix + " " + name);
+  }
+}
+
+
+// Helper function used to install functions on objects.
+function InstallFunctions(object, attributes, functions) {
+  %OptimizeObjectForAddingMultipleProperties(object, functions.length >> 1);
+  for (var i = 0; i < functions.length; i += 2) {
+    var key = functions[i];
+    var f = functions[i + 1];
+    SetFunctionName(f, key);
+    %FunctionRemovePrototype(f);
+    %AddNamedProperty(object, key, f, attributes);
+    %SetNativeFlag(f);
+  }
+  %ToFastProperties(object);
+}
+
+
+function OverrideFunction(object, name, f) {
+  ObjectDefineProperty(object, name, { value: f,
+                                       writeable: true,
+                                       configurable: true,
+                                       enumerable: false });
+  SetFunctionName(f, name);
+  %FunctionRemovePrototype(f);
+  %SetNativeFlag(f);
+}
+
+
+// Helper function to install a getter-only accessor property.
+function InstallGetter(object, name, getter, attributes) {
+  if (typeof attributes == "undefined") {
+    attributes = DONT_ENUM;
+  }
+  SetFunctionName(getter, name, "get");
+  %FunctionRemovePrototype(getter);
+  %DefineAccessorPropertyUnchecked(object, name, getter, null, attributes);
+  %SetNativeFlag(getter);
+}
+
+
+// Helper function to install a getter/setter accessor property.
+function InstallGetterSetter(object, name, getter, setter) {
+  SetFunctionName(getter, name, "get");
+  SetFunctionName(setter, name, "set");
+  %FunctionRemovePrototype(getter);
+  %FunctionRemovePrototype(setter);
+  %DefineAccessorPropertyUnchecked(object, name, getter, setter, DONT_ENUM);
+  %SetNativeFlag(getter);
+  %SetNativeFlag(setter);
+}
+
+
+// Helper function for installing constant properties on objects.
+function InstallConstants(object, constants) {
+  %OptimizeObjectForAddingMultipleProperties(object, constants.length >> 1);
+  var attributes = DONT_ENUM | DONT_DELETE | READ_ONLY;
+  for (var i = 0; i < constants.length; i += 2) {
+    var name = constants[i];
+    var k = constants[i + 1];
+    %AddNamedProperty(object, name, k, attributes);
+  }
+  %ToFastProperties(object);
+}
+
+
+// Prevents changes to the prototype of a built-in function.
+// The "prototype" property of the function object is made non-configurable,
+// and the prototype object is made non-extensible. The latter prevents
+// changing the __proto__ property.
+function SetUpLockedPrototype(constructor, fields, methods) {
+  %CheckIsBootstrapping();
+  var prototype = constructor.prototype;
+  // Install functions first, because this function is used to initialize
+  // PropertyDescriptor itself.
+  var property_count = (methods.length >> 1) + (fields ? fields.length : 0);
+  if (property_count >= 4) {
+    %OptimizeObjectForAddingMultipleProperties(prototype, property_count);
+  }
+  if (fields) {
+    for (var i = 0; i < fields.length; i++) {
+      %AddNamedProperty(prototype, fields[i],
+                        UNDEFINED, DONT_ENUM | DONT_DELETE);
+    }
+  }
+  for (var i = 0; i < methods.length; i += 2) {
+    var key = methods[i];
+    var f = methods[i + 1];
+    %AddNamedProperty(prototype, key, f, DONT_ENUM | DONT_DELETE | READ_ONLY);
+    %SetNativeFlag(f);
+  }
+  %InternalSetPrototype(prototype, null);
+  %ToFastProperties(prototype);
+}
+
+
+// ----------------------------------------------------------------------------
+
 
 // ECMA 262 - 15.1.4
 function GlobalIsNaN(number) {
   number = TO_NUMBER_INLINE(number);
   return NUMBER_IS_NAN(number);
 }
 
 
 // ECMA 262 - 15.1.5
 function GlobalIsFinite(number) {
@@ skipping 54 matching lines @@
 
   return %_CallFunction(global_proxy, f);
 }
 
 
 // ----------------------------------------------------------------------------
 
 // Set up global object.
 var attributes = DONT_ENUM | DONT_DELETE | READ_ONLY;
 
-utils.InstallConstants(global, [
+InstallConstants(global, [
   // ECMA 262 - 15.1.1.1.
   "NaN", NAN,
   // ECMA-262 - 15.1.1.2.
   "Infinity", INFINITY,
   // ECMA-262 - 15.1.1.2.
   "undefined", UNDEFINED,
 ]);
 
 // Set up non-enumerable function on the global object.
-utils.InstallFunctions(global, DONT_ENUM, [
+InstallFunctions(global, DONT_ENUM, [
   "isNaN", GlobalIsNaN,
   "isFinite", GlobalIsFinite,
   "parseInt", GlobalParseInt,
   "parseFloat", GlobalParseFloat,
   "eval", GlobalEval
 ]);
 
 
 // ----------------------------------------------------------------------------
 // Object
@@ skipping 33 matching lines @@
 }
 
 
 // ECMA-262 - 15.2.4.5
 function ObjectHasOwnProperty(V) {
   if (%_IsJSProxy(this)) {
     // TODO(rossberg): adjust once there is a story for symbols vs proxies.
     if (IS_SYMBOL(V)) return false;
 
     var handler = %GetHandler(this);
-    return CallTrap1(handler, "hasOwn", ProxyDerivedHasOwnTrap, $toName(V));
+    return CallTrap1(handler, "hasOwn", $proxyDerivedHasOwnTrap, $toName(V));
   }
   return %HasOwnProperty(TO_OBJECT_INLINE(this), $toName(V));
 }
 
 
 // ECMA-262 - 15.2.4.6
 function ObjectIsPrototypeOf(V) {
   if (!IS_SPEC_OBJECT(V)) return false;
   CHECK_OBJECT_COERCIBLE(this, "Object.prototype.isPrototypeOf");
   return %IsInPrototypeChain(this, V);
@@ skipping 62 matching lines @@
     receiver = %GlobalProxy(ObjectLookupSetter);
   }
   return %LookupAccessor(TO_OBJECT_INLINE(receiver), $toName(name), SETTER);
 }
 
 
 function ObjectKeys(obj) {
   obj = TO_OBJECT_INLINE(obj);
   if (%_IsJSProxy(obj)) {
     var handler = %GetHandler(obj);
-    var names = CallTrap0(handler, "keys", ProxyDerivedKeysTrap);
+    var names = CallTrap0(handler, "keys", $proxyDerivedKeysTrap);
     return ToNameArray(names, "keys", false);
   }
   return %OwnKeys(obj);
 }
 
 
 // ES5 8.10.1.
 function IsAccessorDescriptor(desc) {
   if (IS_UNDEFINED(desc)) return false;
   return desc.hasGetter() || desc.hasSetter();
@@ skipping 136 matching lines @@
   this.enumerable_ = false;
   this.hasEnumerable_ = false;
   this.configurable_ = false;
   this.hasConfigurable_ = false;
   this.get_ = UNDEFINED;
   this.hasGetter_ = false;
   this.set_ = UNDEFINED;
   this.hasSetter_ = false;
 }
 
-utils.SetUpLockedPrototype(PropertyDescriptor, [
+SetUpLockedPrototype(PropertyDescriptor, [
   "value_",
   "hasValue_",
   "writable_",
   "hasWritable_",
   "enumerable_",
   "hasEnumerable_",
   "configurable_",
   "hasConfigurable_",
   "get_",
   "hasGetter_",
@@ skipping 723 matching lines @@
 function ProxyFix(obj) {
   var handler = %GetHandler(obj);
   var props = CallTrap0(handler, "fix", UNDEFINED);
   if (IS_UNDEFINED(props)) {
     throw MakeTypeError(kProxyHandlerReturned, handler, "undefined", "fix");
   }
 
   if (%IsJSFunctionProxy(obj)) {
     var callTrap = %GetCallTrap(obj);
     var constructTrap = %GetConstructTrap(obj);
-    var code = ProxyDelegateCallAndConstruct(callTrap, constructTrap);
+    var code = $proxyDelegateCallAndConstruct(callTrap, constructTrap);
     %Fix(obj);  // becomes a regular function
     %SetCode(obj, code);
     // TODO(rossberg): What about length and other properties? Not specified.
     // We just put in some half-reasonable defaults for now.
     var prototype = new GlobalObject();
     ObjectDefineProperty(prototype, "constructor",
       {value: obj, writable: true, enumerable: false, configurable: true});
     // TODO(v8:1530): defineProperty does not handle prototype and length.
     %FunctionSetPrototype(obj, prototype);
     obj.length = 0;
@@ skipping 157 matching lines @@
 // ----------------------------------------------------------------------------
 // Object
 
 %SetNativeFlag(GlobalObject);
 %SetCode(GlobalObject, ObjectConstructor);
 
 %AddNamedProperty(GlobalObject.prototype, "constructor", GlobalObject,
                   DONT_ENUM);
 
 // Set up non-enumerable functions on the Object.prototype object.
-utils.InstallFunctions(GlobalObject.prototype, DONT_ENUM, [
+InstallFunctions(GlobalObject.prototype, DONT_ENUM, [
   "toString", ObjectToString,
   "toLocaleString", ObjectToLocaleString,
   "valueOf", ObjectValueOf,
   "hasOwnProperty", ObjectHasOwnProperty,
   "isPrototypeOf", ObjectIsPrototypeOf,
   "propertyIsEnumerable", ObjectPropertyIsEnumerable,
   "__defineGetter__", ObjectDefineGetter,
   "__lookupGetter__", ObjectLookupGetter,
   "__defineSetter__", ObjectDefineSetter,
   "__lookupSetter__", ObjectLookupSetter
 ]);
-utils.InstallGetterSetter(GlobalObject.prototype, "__proto__", ObjectGetProto,
+InstallGetterSetter(GlobalObject.prototype, "__proto__", ObjectGetProto,
                     ObjectSetProto);
 
 // Set up non-enumerable functions in the Object object.
-utils.InstallFunctions(GlobalObject, DONT_ENUM, [
+InstallFunctions(GlobalObject, DONT_ENUM, [
   "keys", ObjectKeys,
   "create", ObjectCreate,
   "defineProperty", ObjectDefineProperty,
   "defineProperties", ObjectDefineProperties,
   "freeze", ObjectFreezeJS,
   "getPrototypeOf", ObjectGetPrototypeOf,
   "setPrototypeOf", ObjectSetPrototypeOf,
   "getOwnPropertyDescriptor", ObjectGetOwnPropertyDescriptor,
   "getOwnPropertyNames", ObjectGetOwnPropertyNames,
   // getOwnPropertySymbols is added in symbol.js.
@@ skipping 44 matching lines @@
 }
 
 
 // ----------------------------------------------------------------------------
 
 %SetCode(GlobalBoolean, BooleanConstructor);
 %FunctionSetPrototype(GlobalBoolean, new GlobalBoolean(false));
 %AddNamedProperty(GlobalBoolean.prototype, "constructor", GlobalBoolean,
                   DONT_ENUM);
 
-utils.InstallFunctions(GlobalBoolean.prototype, DONT_ENUM, [
+InstallFunctions(GlobalBoolean.prototype, DONT_ENUM, [
   "toString", BooleanToString,
   "valueOf", BooleanValueOf
 ]);
 
 
 // ----------------------------------------------------------------------------
 // Number
 
 function NumberConstructor(x) {
   var value = %_ArgumentsLength() == 0 ? 0 : $toNumber(x);
@@ skipping 156 matching lines @@
 // ----------------------------------------------------------------------------
 
 %SetCode(GlobalNumber, NumberConstructor);
 %FunctionSetPrototype(GlobalNumber, new GlobalNumber(0));
 
 %OptimizeObjectForAddingMultipleProperties(GlobalNumber.prototype, 8);
 // Set up the constructor property on the Number prototype object.
 %AddNamedProperty(GlobalNumber.prototype, "constructor", GlobalNumber,
                   DONT_ENUM);
 
-utils.InstallConstants(GlobalNumber, [
+InstallConstants(GlobalNumber, [
   // ECMA-262 section 15.7.3.1.
   "MAX_VALUE", 1.7976931348623157e+308,
   // ECMA-262 section 15.7.3.2.
   "MIN_VALUE", 5e-324,
   // ECMA-262 section 15.7.3.3.
   "NaN", NAN,
   // ECMA-262 section 15.7.3.4.
   "NEGATIVE_INFINITY", -INFINITY,
   // ECMA-262 section 15.7.3.5.
   "POSITIVE_INFINITY", INFINITY,
 
   // --- Harmony constants (no spec refs until settled.)
 
   "MAX_SAFE_INTEGER", %_MathPow(2, 53) - 1,
   "MIN_SAFE_INTEGER", -%_MathPow(2, 53) + 1,
   "EPSILON", %_MathPow(2, -52)
 ]);
 
 // Set up non-enumerable functions on the Number prototype object.
-utils.InstallFunctions(GlobalNumber.prototype, DONT_ENUM, [
+InstallFunctions(GlobalNumber.prototype, DONT_ENUM, [
   "toString", NumberToStringJS,
   "toLocaleString", NumberToLocaleString,
   "valueOf", NumberValueOf,
   "toFixed", NumberToFixedJS,
   "toExponential", NumberToExponentialJS,
   "toPrecision", NumberToPrecisionJS
 ]);
 
 // Harmony Number constructor additions
-utils.InstallFunctions(GlobalNumber, DONT_ENUM, [
+InstallFunctions(GlobalNumber, DONT_ENUM, [
   "isFinite", NumberIsFinite,
   "isInteger", NumberIsInteger,
   "isNaN", NumberIsNaN,
   "isSafeInteger", NumberIsSafeInteger,
   "parseInt", GlobalParseInt,
   "parseFloat", GlobalParseFloat
 ]);
 
 %SetForceInlineFlag(NumberIsNaN);
 
@@ skipping 147 matching lines @@
   return f;
 }
 
 
 // ----------------------------------------------------------------------------
 
 %SetCode(GlobalFunction, FunctionConstructor);
 %AddNamedProperty(GlobalFunction.prototype, "constructor", GlobalFunction,
                   DONT_ENUM);
 
-utils.InstallFunctions(GlobalFunction.prototype, DONT_ENUM, [
+InstallFunctions(GlobalFunction.prototype, DONT_ENUM, [
   "bind", FunctionBind,
   "toString", FunctionToString
 ]);
 
 // ----------------------------------------------------------------------------
 // Iterator related spec functions.
 
 // ES6 rev 33, 2015-02-12
 // 7.4.1 GetIterator ( obj, method )
 function GetIterator(obj, method) {
   if (IS_UNDEFINED(method)) {
     method = obj[symbolIterator];
   }
   if (!IS_SPEC_FUNCTION(method)) {
     throw MakeTypeError(kNotIterable, obj);
   }
   var iterator = %_CallFunction(obj, method);
   if (!IS_SPEC_OBJECT(iterator)) {
     throw MakeTypeError(kNotAnIterator, iterator);
   }
   return iterator;
 }
 
-// ----------------------------------------------------------------------------
-// Exports
+//----------------------------------------------------------------------------
 
+$delete = Delete;
 $functionSourceString = FunctionSourceString;
+$getIterator = GetIterator;
+$getMethod = GetMethod;
 $globalEval = GlobalEval;
+$installConstants = InstallConstants;
+$installFunctions = InstallFunctions;
+$installGetter = InstallGetter;
+$isFinite = GlobalIsFinite;
+$isNaN = GlobalIsNaN;
+$newFunctionString = NewFunctionString;
+$numberIsNaN = NumberIsNaN;
+$objectDefineProperties = ObjectDefineProperties;
+$objectDefineProperty = ObjectDefineProperty;
+$objectFreeze = ObjectFreezeJS;
 $objectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor;
+$objectGetOwnPropertyKeys = ObjectGetOwnPropertyKeys;
+$objectHasOwnProperty = ObjectHasOwnProperty;
+$objectIsFrozen = ObjectIsFrozen;
+$objectIsSealed = ObjectIsSealed;
+$objectLookupGetter = ObjectLookupGetter;
+$objectLookupSetter = ObjectLookupSetter;
+$objectToString = ObjectToString;
+$overrideFunction = OverrideFunction;
+$ownPropertyKeys = OwnPropertyKeys;
+$setFunctionName = SetFunctionName;
+$setUpLockedPrototype = SetUpLockedPrototype;
 $toCompletePropertyDescriptor = ToCompletePropertyDescriptor;
-
-utils.ObjectDefineProperties = ObjectDefineProperties;
-utils.ObjectDefineProperty = ObjectDefineProperty;
-
-utils.Export(function(to) {
-  to.Delete = Delete;
-  to.GetIterator = GetIterator;
-  to.GetMethod = GetMethod;
-  to.IsFinite = GlobalIsFinite;
-  to.IsNaN = GlobalIsNaN;
-  to.NewFunctionString = NewFunctionString;
-  to.NumberIsNaN = NumberIsNaN;
-  to.ObjectDefineProperty = ObjectDefineProperty;
-  to.ObjectFreeze = ObjectFreezeJS;
-  to.ObjectGetOwnPropertyKeys = ObjectGetOwnPropertyKeys;
-  to.ObjectHasOwnProperty = ObjectHasOwnProperty;
-  to.ObjectIsFrozen = ObjectIsFrozen;
-  to.ObjectIsSealed = ObjectIsSealed;
-  to.ObjectToString = ObjectToString;
-  to.OwnPropertyKeys = OwnPropertyKeys;
-  to.ToNameArray = ToNameArray;
-});
+$toNameArray = ToNameArray;
 
 })