Add TypedArray.from method

src/harmony-typedarray.js

 // Copyright 2014 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, exports) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 macro TYPED_ARRAYS(FUNCTION)
 // arrayIds below should be synchronized with Runtime_TypedArrayInitialize.
 FUNCTION(Uint8Array)
 FUNCTION(Int8Array)
 FUNCTION(Uint16Array)
 FUNCTION(Int16Array)
 FUNCTION(Uint32Array)
 FUNCTION(Int32Array)
 FUNCTION(Float32Array)
 FUNCTION(Float64Array)
 FUNCTION(Uint8ClampedArray)
 endmacro
 
 macro DECLARE_GLOBALS(NAME)
 var GlobalNAME = global.NAME;
 endmacro
 
 TYPED_ARRAYS(DECLARE_GLOBALS)
+DECLARE_GLOBALS(Array)
 
 // -------------------------------------------------------------------
 
 function TypedArrayCopyWithin(target, start, end) {
   if (!%IsTypedArray(this)) throw MakeTypeError(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
-  // TODO(dehrenberg): Replace with a memcpy for better performance
+  // TODO(littledan): Replace with a memcpy for better performance
   return $innerArrayCopyWithin(target, start, end, this, length);
 }
 %FunctionSetLength(TypedArrayCopyWithin, 2);
 
 // ES6 draft 05-05-15, section 22.2.3.7
 function TypedArrayEvery(f, receiver) {
   if (!%IsTypedArray(this)) throw MakeTypeError(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
@@ skipping 45 matching lines @@
 // ES6 draft 08-24-14, section 22.2.2.2
 function TypedArrayOf() {
   var length = %_ArgumentsLength();
   var array = new this(length);
   for (var i = 0; i < length; i++) {
     array[i] = %_Arguments(i);
   }
   return array;
 }
 
+function ConstructTypedArray(constructor, array) {
+  // TODO(littledan): This is an approximation of the spec, which requires
+  // that only real TypedArray classes should be accepted (22.2.2.1.1)
+  if (!IS_SPEC_OBJECT(constructor) || IS_UNDEFINED(constructor.prototype) ||
+      !%HasOwnProperty(constructor.prototype, "BYTES_PER_ELEMENT")) {
+    throw MakeTypeError(kNotTypedArray);
+  }
+
+  // TODO(littledan): The spec requires that, rather than directly calling
+  // the constructor, a TypedArray is created with the proper proto and
+  // underlying size and element size, and elements are put in one by one.
+  // By contrast, this would allow subclasses to make a radically different
+  // constructor with different semantics.
+  return new constructor(array);
+}
+
+function TypedArrayFrom(source, mapfn, thisArg) {
+  var array = %_CallFunction(GlobalArray, source, mapfn, thisArg, $arrayFrom);

[arv (Not doing code reviews), 2015/05/16 18:23:45]

Add todo. It would surely be better to not have a temporary array.

Can you do the $innerArrayFrom solution here too?

[dehrenberg, 2015/05/18 17:56:50]

The problem is that, if the source is iterable, then we don't know its length
until we get all the way through it. So we have to iterate through the whole
thing, and then make a TypedArray of that length. I don't really see an 'inner'
part that I could pull out.
The only way I could see to speed this up would be to implement a TypedVector
(TypedArray supporting a push method) and execute 'from' directly onto that.
This would be a bit of work, and may or may not be faster. I added a todo.

+  return ConstructTypedArray(this, array);
+}
+%FunctionSetLength(TypedArrayFrom, 1);
+
+// TODO(littledan): Fix the TypedArray proto chain (bug v8:4085).
 macro EXTEND_TYPED_ARRAY(NAME)
   // Set up non-enumerable functions on the object.
   $installFunctions(GlobalNAME, DONT_ENUM | DONT_DELETE | READ_ONLY, [
+    "from", TypedArrayFrom,
     "of", TypedArrayOf
   ]);
 
   // Set up non-enumerable functions on the prototype object.
   $installFunctions(GlobalNAME.prototype, DONT_ENUM, [
     "copyWithin", TypedArrayCopyWithin,
     "every", TypedArrayEvery,
     "forEach", TypedArrayForEach,
     "find", TypedArrayFind,
     "findIndex", TypedArrayFindIndex,
     "fill", TypedArrayFill
   ]);
 endmacro
 
 TYPED_ARRAYS(EXTEND_TYPED_ARRAY)
 
 })