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
+function ArrayFrom(arrayLike /* [, mapfn [, receiver] ] */) { // length == 1

[arv (Not doing code reviews), 2014/07/02 18:26:43]

Just keep the mapfn and receiver here. You can set the function length in
HarmonyArrayExtendArrayPrototype.

[caitp (gmail), 2014/07/02 19:22:05]

I haven't found a way to set the arity of a function in the tree, do you have an
example? All of the variations on DefineProperty or SetProperty won't seem to do
it.

[arv (Not doing code reviews), 2014/07/02 19:29:09]

%FunctionSetLength(f, len);

+  var items = ToObject(arrayLike);
+  var mapping = false;
+  var array;
+  var mapfn;
+  var receiver;
+
+  if (%_ArgumentsLength() > 1) {
+    mapfn = %_Arguments(1);
+    if (%_ArgumentsLength() > 2) {
+      receiver = %_Arguments(2);
+    }
+  }
+
+  if (!IS_UNDEFINED(mapfn)) {
+    if (!IS_SPEC_FUNCTION(mapfn)) {
+      throw MakeTypeError('called_non_callable', [ mapfn ]);
+    }
+    if (IS_NULL_OR_UNDEFINED(receiver)) {
+      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;

[aandrey, 2014/07/02 18:28:15]

var stepping = mapping && DEBUG_IS_ACTIVE &&
%DebugCallbackSupportsStepping(mapfn);

+
+  if (!IS_UNDEFINED(usingIterator)) {
+    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 ]);
+    }
+
+    array = [];

[arv (Not doing code reviews), 2014/07/02 18:26:43]

This should use new this if this is a constructor.

[arv (Not doing code reviews), 2014/07/02 18:26:43]

The ordering here is not correct.

[caitp (gmail), 2014/07/02 19:22:05]

You mean, because the array is created after conditionally throwing? I felt that
this might be less wasteful in cases where it does throw, but alright

[arv (Not doing code reviews), 2014/07/02 19:29:09]

We could try to change the spec. But for now, we should just match it and track
any future changes.

+    var next;
+    while (!(next = iterator.next()).done) {
+      value = next.value;
+      if (mapping) {
+        value = %_CallFunction(receiver, value, k, mapfn);

[aandrey, 2014/07/02 18:28:15]

if (stepping) %DebugPrepareStepInIfStepping(mapfn);

+      }
+      array[k++] = value;
+    }

[arv (Not doing code reviews), 2014/07/02 18:26:43]

Let putStatus be Put(A, "length", k, true).

is missing. That is important when this is called on something other than an
array.

+  } else {
+    var len = +items.length;

[arv (Not doing code reviews), 2014/07/02 18:26:43]

How about adding TO_LENGTH to macros.py?

[caitp (gmail), 2014/07/02 19:22:05]

Will do, but I'm not actually sure this is really correct, I think some of the
other harmony array routines are just using ToInteger(array.length);

+    if (len < +0 || len !== len) {
+      len = +0;

[arv (Not doing code reviews), 2014/07/02 18:26:43]

len = 0

+    }
+
+    array = new $Array(len);

[arv (Not doing code reviews), 2014/07/02 18:26:43]

new this here as well.

[caitp (gmail), 2014/07/02 19:22:05]

After reading that, I think I understand what you mean. But please clarify just
in case I'm not getting it.

If that is what you mean, per the spec, we do this (`Let A be the result of
calling the [[Construct]] internal method of C with an argument list containing
the single item len.`) only on the condition `IsConstructor(C)`.

I'm looking for a way to figure out if `this` actually _is_ a constructor, would
`IS_FUNCTION(this)` be good enough for that?

[arv (Not doing code reviews), 2014/07/02 19:29:09]

Unfortunately V8 has no concept of [[Constructor]] but a good approximation for
now is IS_FUNCTION (and maybe check for a prototype?)

[rossberg, 2014/07/03 11:16:57]

IS_SPEC_FUNCTION is more what you want.

+    for (; k < len; ++k) {
+      value = items[k];
+      if (mapping) {
+        value = %_CallFunction(receiver, value, k, mapfn);

[aandrey, 2014/07/02 18:28:15]

ditto

+      }
+      array[k] = value;
+    }
+  }
+

[arv (Not doing code reviews), 2014/07/02 18:26:43]

Put length here as well.

+  return array;
+}
+
 // -------------------------------------------------------------------
 
 function HarmonyArrayExtendArrayPrototype() {
   %CheckIsBootstrapping();
 
+  // 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();