Allow TypedArrays to be initialized with iterables

src/typedarray.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.
 
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 25 matching lines @@
 TYPED_ARRAYS(DECLARE_GLOBALS)
 
 var MathMax;
 var MathMin;
 
 utils.Import(function(from) {
   MathMax = from.MathMax;
   MathMin = from.MathMin;
 });
 
+var InternalArray = utils.InternalArray;
+
 // --------------- Typed Arrays ---------------------
 
 macro TYPED_ARRAY_CONSTRUCTOR(ARRAY_ID, NAME, ELEMENT_SIZE)
 function NAMEConstructByArrayBuffer(obj, buffer, byteOffset, length) {
   if (!IS_UNDEFINED(byteOffset)) {
       byteOffset =
           $toPositiveInteger(byteOffset, kInvalidTypedArrayLength);
   }
   if (!IS_UNDEFINED(length)) {
       length = $toPositiveInteger(length, kInvalidTypedArrayLength);
@@ skipping 67 matching lines @@
   }
   if (!initialized) {
     for (var i = 0; i < l; i++) {
       // It is crucial that we let any execptions from arrayLike[i]
       // propagate outside the function.
       obj[i] = arrayLike[i];
     }
   }
 }
 
+function NAMEConstructByIterable(obj, iterable, iteratorFn) {
+  var list = new InternalArray();
+  var iterator = %_CallFunction(iterable, iteratorFn);
+  while (true) {
+    var current = iterator.next();
+    if (!IS_OBJECT(current)) {

[adamk, 2015/06/12 18:06:45]

I think you want IS_SPEC_OBJECT here.

The proper tests for this are sadly quite large (and probably not worth adding
just for this case), hope we can replace this with a macro soon.

[Dan Ehrenberg, 2015/06/13 00:11:40]

How's this, just using for-of with a wrapper? We can factor that pattern into a
function if we want.

+      throw MakeTypeError(kIteratorResultNotAnObject, current);
+    }
+    if (current.done) break;
+    list.push(current.value);
+  }
+  NAMEConstructByArrayLike(obj, list);
+}
+
 function NAMEConstructor(arg1, arg2, arg3) {
   if (%_IsConstructCall()) {
     if (IS_ARRAYBUFFER(arg1) || IS_SHAREDARRAYBUFFER(arg1)) {
       NAMEConstructByArrayBuffer(this, arg1, arg2, arg3);
     } else if (IS_NUMBER(arg1) || IS_STRING(arg1) ||
                IS_BOOLEAN(arg1) || IS_UNDEFINED(arg1)) {
       NAMEConstructByLength(this, arg1);
     } else {
-      NAMEConstructByArrayLike(this, arg1);
+      var iteratorFn = arg1[symbolIterator];
+      if (IS_UNDEFINED(iteratorFn) || iteratorFn === $arrayValues) {
+        NAMEConstructByArrayLike(this, arg1);
+      } else {
+        // TODO(littledan): The code here is lazy and looks up @@iterator
+        // twice. Currently, that's fine, but it'll be observable with proxies.
+        NAMEConstructByIterable(this, arg1, iteratorFn);
+      }
     }
   } else {
     throw MakeTypeError(kConstructorNotFunction, "NAME")
   }
 }
 
 function NAME_GetBuffer() {
   if (!(%_ClassOf(this) === 'NAME')) {
     throw MakeTypeError(kIncompatibleMethodReceiver, "NAME.buffer", this);
   }
@@ skipping 321 matching lines @@
   "setUint32", DataViewSetUint32JS,
 
   "getFloat32", DataViewGetFloat32JS,
   "setFloat32", DataViewSetFloat32JS,
 
   "getFloat64", DataViewGetFloat64JS,
   "setFloat64", DataViewSetFloat64JS
 ]);
 
 })