Reland [typedarrays] Check detached buffer at start of typed array methods

src/js/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();
 
 // -------------------------------------------------------------------
 // Imports
 
 // array.js has to come before typedarray.js for this to work
 var ArrayToString = utils.ImportNow("ArrayToString");
-var ArrayValues;
 var GetIterator;
 var GetMethod;
 var GlobalArray = global.Array;
 var GlobalArrayBuffer = global.ArrayBuffer;
 var GlobalArrayBufferPrototype = GlobalArrayBuffer.prototype;
 var GlobalObject = global.Object;
 var InnerArrayFind;
 var InnerArrayFindIndex;
 var InnerArrayJoin;
 var InnerArraySort;
@@ skipping 19 matching lines @@
 
 macro DECLARE_GLOBALS(NAME, SIZE)
 var GlobalNAME = global.NAME;
 endmacro
 
 TYPED_ARRAYS(DECLARE_GLOBALS)
 
 var GlobalTypedArray = %object_get_prototype_of(GlobalUint8Array);
 
 utils.Import(function(from) {
-  ArrayValues = from.ArrayValues;
   GetIterator = from.GetIterator;
   GetMethod = from.GetMethod;
   InnerArrayFind = from.InnerArrayFind;
   InnerArrayFindIndex = from.InnerArrayFindIndex;
   InnerArrayJoin = from.InnerArrayJoin;
   InnerArraySort = from.InnerArraySort;
   InnerArrayToLocaleString = from.InnerArrayToLocaleString;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
 });
@@ skipping 12 matching lines @@
     return defaultConstructor;
   }
   if (%IsConstructor(species)) {
     return species;
   }
   throw %make_type_error(kSpeciesNotConstructor);
 }
 
 // --------------- Typed Arrays ---------------------
 
+// ES6 section 22.2.3.5.1 ValidateTypedArray ( O )
+function ValidateTypedArray(array, methodName) {
+  if (!IS_TYPEDARRAY(array)) throw %make_type_error(kNotTypedArray);
+
+  if (%_ArrayBufferViewWasNeutered(array))
+    throw %make_type_error(kDetachedOperation, methodName);
+}
+
 function TypedArrayDefaultConstructor(typedArray) {
   switch (%_ClassOf(typedArray)) {
 macro TYPED_ARRAY_CONSTRUCTOR_CASE(NAME, ELEMENT_SIZE)
     case "NAME":
       return GlobalNAME;
 endmacro
 TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTOR_CASE)
   }
   // The TypeError should not be generated since all callers should
   // have already called ValidateTypedArray.
   throw %make_type_error(kIncompatibleMethodReceiver,
                       "TypedArrayDefaultConstructor", this);
 }
 
 function TypedArrayCreate(constructor, arg0, arg1, arg2) {
   if (IS_UNDEFINED(arg1)) {
     var newTypedArray = new constructor(arg0);
   } else {
     var newTypedArray = new constructor(arg0, arg1, arg2);
   }
-  if (!IS_TYPEDARRAY(newTypedArray)) throw %make_type_error(kNotTypedArray);
-  // TODO(littledan): Check for being detached, here and elsewhere
-  // All callers where the first argument is a Number have no additional
-  // arguments.
+  ValidateTypedArray(newTypedArray, "TypedArrayCreate");
   if (IS_NUMBER(arg0) && %_TypedArrayGetLength(newTypedArray) < arg0) {
     throw %make_type_error(kTypedArrayTooShort);
   }
   return newTypedArray;
 }
 
-function TypedArraySpeciesCreate(exemplar, arg0, arg1, arg2, conservative) {
+function TypedArraySpeciesCreate(exemplar, arg0, arg1, arg2) {
   var defaultConstructor = TypedArrayDefaultConstructor(exemplar);
-  var constructor = SpeciesConstructor(exemplar, defaultConstructor,
-                                       conservative);
+  var constructor = SpeciesConstructor(exemplar, defaultConstructor);
   return TypedArrayCreate(constructor, arg0, arg1, arg2);
 }
 
 macro TYPED_ARRAY_CONSTRUCTOR(NAME, ELEMENT_SIZE)
 function NAMEConstructByIterable(obj, iterable, iteratorFn) {
   if (%IterableToListCanBeElided(iterable)) {
     // This .length access is unobservable, because it being observable would
     // mean that iteration has side effects, and we wouldn't reach this path.
     %typed_array_construct_by_array_like(
         obj, iterable, iterable.length, ELEMENT_SIZE);
@@ skipping 84 matching lines @@
     endInt = MinSimple(endInt, srcLength);
   }
 
   if (endInt < beginInt) {
     endInt = beginInt;
   }
 
   var newLength = endInt - beginInt;
   var beginByteOffset =
       %_ArrayBufferViewGetByteOffset(this) + beginInt * ELEMENT_SIZE;
-  // BUG(v8:4665): For web compatibility, subarray needs to always build an
-  // instance of the default constructor.
-  // TODO(littledan): Switch to the standard or standardize the fix
-  return new GlobalNAME(%TypedArrayGetBuffer(this), beginByteOffset, newLength);
+  return TypedArraySpeciesCreate(this, %TypedArrayGetBuffer(this),
+                                 beginByteOffset, newLength);
 }
 endmacro
 
 TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTOR)
 
 function TypedArraySubArray(begin, end) {
   switch (%_ClassOf(this)) {
 macro TYPED_ARRAY_SUBARRAY_CASE(NAME, ELEMENT_SIZE)
     case "NAME":
       return %_Call(NAMESubArray, this, begin, end);
 endmacro
 TYPED_ARRAYS(TYPED_ARRAY_SUBARRAY_CASE)
   }
   throw %make_type_error(kIncompatibleMethodReceiver,
-                      "get TypedArray.prototype.subarray", this);
+                      "get %TypedArray%.prototype.subarray", this);
 }
 %SetForceInlineFlag(TypedArraySubArray);
 
 
 
 function TypedArraySetFromArrayLike(target, source, sourceLength, offset) {
   if (offset > 0) {
     for (var i = 0; i < sourceLength; i++) {
       target[offset + i] = source[i];
     }
@@ skipping 112 matching lines @@
     if (i in array) {
       var element = array[i];
       if (!%_Call(f, receiver, element, i, array)) return false;
     }
   }
   return true;
 }
 
 // ES6 draft 05-05-15, section 22.2.3.7
 function TypedArrayEvery(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.every");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerTypedArrayEvery(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArrayEvery, 1);
 
 function InnerTypedArrayForEach(f, receiver, array, length) {
   if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   if (IS_UNDEFINED(receiver)) {
     for (var i = 0; i < length; i++) {
       if (i in array) {
         var element = array[i];
         f(element, i, array);
       }
     }
   } else {
     for (var i = 0; i < length; i++) {
       if (i in array) {
         var element = array[i];
         %_Call(f, receiver, element, i, array);
       }
     }
   }
 }
 
 // ES6 draft 08-24-14, section 22.2.3.12
 function TypedArrayForEach(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.forEach");
 
   var length = %_TypedArrayGetLength(this);
 
   InnerTypedArrayForEach(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArrayForEach, 1);
 
 // The following functions cannot be made efficient on sparse arrays while
 // preserving the semantics, since the calls to the receiver function can add
 // or delete elements from the array.
 function InnerTypedArrayFilter(f, receiver, array, length, result) {
   var result_length = 0;
   for (var i = 0; i < length; i++) {
     if (i in array) {
       var element = array[i];
       if (%_Call(f, receiver, element, i, array)) {
         %CreateDataProperty(result, result_length, element);
         result_length++;
       }
     }
   }
   return result;
 }
 
 
 // ES6 draft 07-15-13, section 22.2.3.9
 function TypedArrayFilter(f, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypeArray%.prototype.filter");
 
   var length = %_TypedArrayGetLength(this);
   if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   var result = new InternalArray();
   InnerTypedArrayFilter(f, thisArg, this, length, result);
   var captured = result.length;
   var output = TypedArraySpeciesCreate(this, captured);
   for (var i = 0; i < captured; i++) {
     output[i] = result[i];
   }
   return output;
 }
 %FunctionSetLength(TypedArrayFilter, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.10
 function TypedArrayFind(predicate, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.find");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayFind(predicate, thisArg, this, length);
 }
 %FunctionSetLength(TypedArrayFind, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.11
 function TypedArrayFindIndex(predicate, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.findIndex");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayFindIndex(predicate, thisArg, this, length);
 }
 %FunctionSetLength(TypedArrayFindIndex, 1);
 
 
 // ES6 draft 05-18-15, section 22.2.3.25
 function TypedArraySort(comparefn) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.sort");
 
   var length = %_TypedArrayGetLength(this);
 
   if (IS_UNDEFINED(comparefn)) {
     return %TypedArraySortFast(this);
   }
 
   return InnerArraySort(this, length, comparefn);
 }
 
 
 // ES6 draft 07-15-13, section 22.2.3.18
 function TypedArrayMap(f, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.map");
 
   var length = %_TypedArrayGetLength(this);
   var result = TypedArraySpeciesCreate(this, length);
   if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   for (var i = 0; i < length; i++) {
     var element = this[i];
     result[i] = %_Call(f, thisArg, element, i, this);
   }
   return result;
 }
 %FunctionSetLength(TypedArrayMap, 1);
 
 function InnerTypedArraySome(f, receiver, array, length) {
   if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   for (var i = 0; i < length; i++) {
     if (i in array) {
       var element = array[i];
       if (%_Call(f, receiver, element, i, array)) return true;
     }
   }
   return false;
 }
 
 // ES6 draft 05-05-15, section 22.2.3.24
 function TypedArraySome(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.some");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerTypedArraySome(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArraySome, 1);
 
 
 // ES6 section 22.2.3.27
 function TypedArrayToLocaleString() {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.toLocaleString");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayToLocaleString(this, length);
 }
 
 
 // ES6 section 22.2.3.14
 function TypedArrayJoin(separator) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.join");
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayJoin(separator, this, length);
 }
 
 function InnerTypedArrayReduce(
     callback, current, array, length, argumentsLength) {
   if (!IS_CALLABLE(callback)) {
     throw %make_type_error(kCalledNonCallable, callback);
@@ skipping 14 matching lines @@
     if (i in array) {
       var element = array[i];
       current = callback(current, element, i, array);
     }
   }
   return current;
 }
 
 // ES6 draft 07-15-13, section 22.2.3.19
 function TypedArrayReduce(callback, current) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.reduce");
 
   var length = %_TypedArrayGetLength(this);
   return InnerTypedArrayReduce(
       callback, current, this, length, arguments.length);
 }
 %FunctionSetLength(TypedArrayReduce, 1);
 
 function InnerArrayReduceRight(callback, current, array, length,
                                argumentsLength) {
   if (!IS_CALLABLE(callback)) {
@@ skipping 15 matching lines @@
     if (i in array) {
       var element = array[i];
       current = callback(current, element, i, array);
     }
   }
   return current;
 }
 
 // ES6 draft 07-15-13, section 22.2.3.19
 function TypedArrayReduceRight(callback, current) {
-  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
+  ValidateTypedArray(this, "%TypedArray%.prototype.reduceRight");
 
   var length = %_TypedArrayGetLength(this);
   return InnerArrayReduceRight(callback, current, this, length,
                                arguments.length);
 }
 %FunctionSetLength(TypedArrayReduceRight, 1);
 
 
 // ES6 draft 08-24-14, section 22.2.2.2
 function TypedArrayOf() {
@@ skipping 100 matching lines @@
   %AddNamedProperty(GlobalNAME.prototype,
                     "constructor", global.NAME, DONT_ENUM);
   %AddNamedProperty(GlobalNAME.prototype,
                     "BYTES_PER_ELEMENT", ELEMENT_SIZE,
                     READ_ONLY | DONT_ENUM | DONT_DELETE);
 endmacro
 
 TYPED_ARRAYS(SETUP_TYPED_ARRAY)
 
 })