Implement Array.from()

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.
 
 'use strict';
 
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Array = global.Array;
 
@@ skipping 105 matching lines @@
   if ((end - i) > 0 && ObjectIsFrozen(array)) {
     throw MakeTypeError("array_functions_on_frozen",
                         ["Array.prototype.fill"]);
   }
 
   for (; i < end; i++)
     array[i] = value;
   return array;
 }
 
+// ES6, 22.1.2.1 --- Requires harmony_symbols and harmony_iteration

[arv (Not doing code reviews), 2014/07/16 20:31:48]

Why does this depend in harmony_iteration?

[caitp (gmail), 2014/07/19 18:29:06]

There are two cases in the Array.from spec: 1) iterables, and 2) array-like
objects.

The dependency on iterators is important for things like strings especially,
because treating strings as array-like objects causes problems with surrogate
pairs, while iterating over string characters doesn't.

(without this flag, one of the tests from mozilla verifying that this works
correctly for Array.from(string) will fail)

[arv (Not doing code reviews), 2014/07/21 18:00:33]

I can see why the test depends on harmony_iteration but this code does not.
Also, if it did you would have needed to add a DEFINE_IMPLICATION in
flag-definitions.h.

So, just update the comment and all is good.

+function ArrayFrom(arrayLike, mapfn, receiver) {
+  var constructor = $Array;
+  var items = ToObject(arrayLike);
+  var mapping = false;
+  var array;
+
+  // FIXME: Implement IsConstructor (ES6 section 7.2.5) instead of IS_SPEC_FUNCTION
+  if (IS_SPEC_FUNCTION(this)) {
+    constructor = this;
+  }
+
+  if (!IS_UNDEFINED(mapfn)) {
+    if (!IS_SPEC_FUNCTION(mapfn)) {
+      throw MakeTypeError('called_non_callable', [ mapfn ]);
+    }
+    if (IS_NULL_OR_UNDEFINED(receiver)) {

[arv (Not doing code reviews), 2014/07/16 20:31:48]

Why is null included here? I thought this was part of bullet point 5 but I don't
see how this relates to the spec?

[caitp (gmail), 2014/07/19 18:29:06]

The pattern was just taken from one of the ES5 routines, but yes, it should be
undefined or callable or throw --- I'll fix that up.

+      receiver = %GetDefaultReceiver(mapfn) || receiver;
+    } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(mapfn)) {
+      receiver = ToObject(receiver);
+    }
+    mapping = true;
+  }
+
+  var usingIterator = items[symbolIterator];
+  var k = 0;
+  var value;
+
+  if (!IS_UNDEFINED(usingIterator)) {
+    array = new constructor();
+
+    if (!IS_SPEC_FUNCTION(usingIterator)) {
+      throw MakeTypeError('called_non_callable', [ usingIterator ]);
+    }
+
+    var iterator = %_CallFunction(items, usingIterator);
+    if (!IS_OBJECT(iterator)) {
+      throw MakeTypeError('iterator_result_not_an_object', [ iterator ]);
+    }
+
+    var next;
+    while (!(next = iterator.next()).done) {
+      value = next.value;
+      if (mapping) {
+        value = %_CallFunction(receiver, value, k, mapfn);
+      }
+      array[k++] = value;
+    }
+  } else {
+    var len = TO_LENGTH(items.length);
+
+    array = new constructor(len);
+    for (; k < len; ++k) {
+      value = items[k];
+      if (mapping) {
+        value = %_CallFunction(receiver, value, k, mapfn);
+      }
+      array[k] = value;
+    }
+  }
+
+  array.length = k;
+  return array;
+}
+
 // -------------------------------------------------------------------
 
 function HarmonyArrayExtendArrayPrototype() {
   %CheckIsBootstrapping();
 
+  %FunctionSetLength(ArrayFrom, 1);
+
+  // Set up non-enumerable functions on the Array object.
+  InstallFunctions($Array, DONT_ENUM, $Array(
+    "from", ArrayFrom
+  ));
+
   // Set up the non-enumerable functions on the Array prototype object.
   InstallFunctions($Array.prototype, DONT_ENUM, $Array(
     "find", ArrayFind,
     "findIndex", ArrayFindIndex,
     "fill", ArrayFill
   ));
 }
 
 HarmonyArrayExtendArrayPrototype();