Revert of Revert of Hook up more import/exports in natives.

src/harmony-array.js

 // Copyright 2013 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 $innerArrayCopyWithin;
-var $innerArrayFill;
-var $innerArrayFind;
-var $innerArrayFindIndex;
-var $arrayFrom;
-
 (function(global, utils) {
 
 'use strict';
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var GlobalArray = global.Array;
 var GlobalSymbol = global.Symbol;
 
+var GetIterator;
+var GetMethod;
 var MathMax;
 var MathMin;
+var ObjectIsFrozen;
 
 utils.Import(function(from) {
+  GetIterator = from.GetIterator;
+  GetMethod = from.GetMethod;
   MathMax = from.MathMax;
   MathMin = from.MathMin;
+  ObjectIsFrozen = from.ObjectIsFrozen;
 });
 
 // -------------------------------------------------------------------
 
 function InnerArrayCopyWithin(target, start, end, array, length) {
   target = TO_INTEGER(target);
   var to;
   if (target < 0) {
     to = MathMax(length + target, 0);
   } else {
@@ skipping 30 matching lines @@
     } else {
       delete array[to];
     }
     from = from + direction;
     to = to + direction;
     count--;
   }
 
   return array;
 }
-$innerArrayCopyWithin = InnerArrayCopyWithin;
 
 // ES6 draft 03-17-15, section 22.1.3.3
 function ArrayCopyWithin(target, start, end) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.copyWithin");
 
   var array = TO_OBJECT_INLINE(this);
   var length = $toLength(array.length);
 
   return InnerArrayCopyWithin(target, start, end, array, length);
 }
@@ skipping 15 matching lines @@
       var element = array[i];
       var newThisArg = needs_wrapper ? $toObject(thisArg) : thisArg;
       if (%_CallFunction(newThisArg, element, i, array, predicate)) {
         return element;
       }
     }
   }
 
   return;
 }
-$innerArrayFind = InnerArrayFind;
 
 // ES6 draft 07-15-13, section 15.4.3.23
 function ArrayFind(predicate, thisArg) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.find");
 
   var array = $toObject(this);
   var length = $toInteger(array.length);
 
   return InnerArrayFind(predicate, thisArg, array, length);
 }
@@ skipping 15 matching lines @@
       var element = array[i];
       var newThisArg = needs_wrapper ? $toObject(thisArg) : thisArg;
       if (%_CallFunction(newThisArg, element, i, array, predicate)) {
         return i;
       }
     }
   }
 
   return -1;
 }
-$innerArrayFindIndex = InnerArrayFindIndex;
 
 // ES6 draft 07-15-13, section 15.4.3.24
 function ArrayFindIndex(predicate, thisArg) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.findIndex");
 
   var array = $toObject(this);
   var length = $toInteger(array.length);
 
   return InnerArrayFindIndex(predicate, thisArg, array, length);
 }
@@ skipping 10 matching lines @@
     if (i > length) i = length;
   }
 
   if (end < 0) {
     end += length;
     if (end < 0) end = 0;
   } else {
     if (end > length) end = length;
   }
 
-  if ((end - i) > 0 && $objectIsFrozen(array)) {
+  if ((end - i) > 0 && ObjectIsFrozen(array)) {
     throw MakeTypeError(kArrayFunctionsOnFrozen);
   }
 
   for (; i < end; i++)
     array[i] = value;
   return array;
 }
-$innerArrayFill = InnerArrayFill;
 
 // ES6, draft 04-05-14, section 22.1.3.6
 function ArrayFill(value, start, end) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.fill");
 
   var array = $toObject(this);
   var length = TO_UINT32(array.length);
 
   return InnerArrayFill(value, start, end, array, length);
 }
 
 // ES6, draft 10-14-14, section 22.1.2.1
 function ArrayFrom(arrayLike, mapfn, receiver) {
   var items = $toObject(arrayLike);
   var mapping = !IS_UNDEFINED(mapfn);
 
   if (mapping) {
     if (!IS_SPEC_FUNCTION(mapfn)) {
       throw MakeTypeError(kCalledNonCallable, mapfn);
     } else if (%IsSloppyModeFunction(mapfn)) {
       if (IS_NULL(receiver)) {
         receiver = UNDEFINED;
       } else if (!IS_UNDEFINED(receiver)) {
         receiver = TO_OBJECT_INLINE(receiver);
       }
     }
   }
 
-  var iterable = $getMethod(items, symbolIterator);
+  var iterable = GetMethod(items, symbolIterator);
   var k;
   var result;
   var mappedValue;
   var nextValue;
 
   if (!IS_UNDEFINED(iterable)) {
     result = %IsConstructor(this) ? new this() : [];
 
-    var iterator = $getIterator(items, iterable);
+    var iterator = GetIterator(items, iterable);
 
     k = 0;
     while (true) {
       var next = iterator.next();
 
       if (!IS_OBJECT(next)) {
         throw MakeTypeError(kIteratorResultNotAnObject, next);
       }
 
       if (next.done) {
@@ skipping 20 matching lines @@
       } else {
         mappedValue = nextValue;
       }
       %AddElement(result, k, mappedValue, NONE);
     }
 
     result.length = k;
     return result;
   }
 }
-$arrayFrom = ArrayFrom;
 
 // ES6, draft 05-22-14, section 22.1.2.3
 function ArrayOf() {
   var length = %_ArgumentsLength();
   var constructor = this;
   // TODO: Implement IsConstructor (ES6 section 7.2.5)
   var array = %IsConstructor(constructor) ? new constructor(length) : [];
   for (var i = 0; i < length; i++) {
     %AddElement(array, i, %_Arguments(i), NONE);
   }
   array.length = length;
   return array;
 }
 
 // -------------------------------------------------------------------
 
-$installConstants(GlobalSymbol, [
+utils.InstallConstants(GlobalSymbol, [
   // TODO(dslomov, caitp): Move to symbol.js when shipping
   "isConcatSpreadable", symbolIsConcatSpreadable
 ]);
 
 %FunctionSetLength(ArrayCopyWithin, 2);
 %FunctionSetLength(ArrayFrom, 1);
 %FunctionSetLength(ArrayFill, 1);
 %FunctionSetLength(ArrayFind, 1);
 %FunctionSetLength(ArrayFindIndex, 1);
 
 // Set up non-enumerable functions on the Array object.
-$installFunctions(GlobalArray, DONT_ENUM, [
+utils.InstallFunctions(GlobalArray, DONT_ENUM, [
   "from", ArrayFrom,
   "of", ArrayOf
 ]);
 
 // Set up the non-enumerable functions on the Array prototype object.
-$installFunctions(GlobalArray.prototype, DONT_ENUM, [
+utils.InstallFunctions(GlobalArray.prototype, DONT_ENUM, [
   "copyWithin", ArrayCopyWithin,
   "find", ArrayFind,
   "findIndex", ArrayFindIndex,
   "fill", ArrayFill
 ]);
 
+// -------------------------------------------------------------------
+// Exports
+
+utils.Export(function(to) {
+  to.ArrayFrom = ArrayFrom;
+  to.InnerArrayCopyWithin = InnerArrayCopyWithin;
+  to.InnerArrayFill = InnerArrayFill;
+  to.InnerArrayFind = InnerArrayFind;
+  to.InnerArrayFindIndex = InnerArrayFindIndex;
+});
+
 })