Make new Harmony constructors subclassing-friendly

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 729 matching lines @@
   }
 
   SetupArrayBuffer(isolate, array_buffer, false, data, allocated_length);
 
   isolate->heap()->AdjustAmountOfExternalAllocatedMemory(allocated_length);
 
   return true;
 }
 
 
+static Failure* ThrowTypeError(Isolate* isolate,
+                               const char* message_id,
+                               const char* arg) {
+  HandleScope scope(isolate);
+  Handle<Object> name_obj =
+      isolate->factory()->NewStringFromAscii(CStrVector(arg));
+  Handle<Object> args[1] = { name_obj };
+  return isolate->Throw(
+      *isolate->factory()->NewTypeError(
+          message_id, HandleVector(args, 1)));
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ArrayBufferInitialize) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
-  CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, holder, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, this_obj, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, byteLength, 1);
+
+  if (!this_obj->IsJSArrayBuffer()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "ArrayBuffer");
+  }
+  Handle<JSArrayBuffer> holder(JSArrayBuffer::cast(*this_obj));
+  if (!holder->byte_length()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", "ArrayBuffer");
+  }
+
   size_t allocated_length;
   if (byteLength->IsSmi()) {
     allocated_length = Smi::cast(*byteLength)->value();
   } else {
     ASSERT(byteLength->IsHeapNumber());
     double value = HeapNumber::cast(*byteLength)->value();
 
     ASSERT(value >= 0);
 
     if (value > std::numeric_limits<size_t>::max()) {
@@ skipping 50 matching lines @@
   ARRAY_ID_UINT16 = 3,
   ARRAY_ID_INT16 = 4,
   ARRAY_ID_UINT32 = 5,
   ARRAY_ID_INT32 = 6,
   ARRAY_ID_FLOAT32 = 7,
   ARRAY_ID_FLOAT64 = 8,
   ARRAY_ID_UINT8C = 9
 };
 
 static void ArrayIdToTypeAndSize(
-    int arrayId, ExternalArrayType* array_type, size_t* element_size) {
+    int arrayId,
+    ExternalArrayType* array_type, size_t* element_size) {
   switch (arrayId) {
     case ARRAY_ID_UINT8:
       *array_type = kExternalUnsignedByteArray;
       *element_size = 1;
       break;
     case ARRAY_ID_INT8:
       *array_type = kExternalByteArray;
       *element_size = 1;
       break;
     case ARRAY_ID_UINT16:
@@ skipping 23 matching lines @@
     case ARRAY_ID_UINT8C:
       *array_type = kExternalPixelArray;
       *element_size = 1;
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
+static const char * GetTypedArrayName(int arrayId) {
+  switch (arrayId) {
+    case ARRAY_ID_UINT8:
+      return "Uint8Array";
+    case ARRAY_ID_INT8:
+      return "Int8Array";
+    case ARRAY_ID_UINT16:
+      return "Uint16Array";
+    case ARRAY_ID_INT16:
+      return "Int16Array";
+    case ARRAY_ID_UINT32:
+      return "Uint32Array";
+    case ARRAY_ID_INT32:
+      return "Int32Array";
+    case ARRAY_ID_FLOAT32:
+      return "Float32Array";
+    case ARRAY_ID_FLOAT64:
+      return "Float64Array";
+    case ARRAY_ID_UINT8C:
+      return "Uint8ClampedArray";
+    default:
+      UNREACHABLE();
+      return NULL;
+  }
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_TypedArrayInitialize) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 5);
-  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, holder, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, this_obj, 0);
   CONVERT_SMI_ARG_CHECKED(arrayId, 1);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, buffer, 2);
   CONVERT_ARG_HANDLE_CHECKED(Object, byte_offset_object, 3);
   CONVERT_ARG_HANDLE_CHECKED(Object, byte_length_object, 4);
 
+  ExternalArrayType array_type = kExternalByteArray;  // Bogus initialization.
+  size_t element_size = 1;  // Bogus initialization.
+  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size);
+
+  if (!this_obj->IsJSTypedArray()) {
+    return ThrowTypeError(isolate, "constructor_not_function",
+                          GetTypedArrayName(arrayId));
+  }
+  Handle<JSTypedArray> holder(JSTypedArray::cast(*this_obj));
+  if (!holder->buffer()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", GetTypedArrayName(arrayId));
+  }
+
   ASSERT(holder->GetInternalFieldCount() ==
       v8::ArrayBufferView::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBufferView::kInternalFieldCount; i++) {
     holder->SetInternalField(i, Smi::FromInt(0));
   }
 
-  ExternalArrayType array_type = kExternalByteArray;  // Bogus initialization.
-  size_t element_size = 1;  // Bogus initialization.
-  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size);
-
   holder->set_buffer(*buffer);
   holder->set_byte_offset(*byte_offset_object);
   holder->set_byte_length(*byte_length_object);
 
   size_t byte_offset = NumberToSize(isolate, *byte_offset_object);
   size_t byte_length = NumberToSize(isolate, *byte_length_object);
   ASSERT(byte_length % element_size == 0);
   size_t length = byte_length / element_size;
 
   Handle<Object> length_obj = isolate->factory()->NewNumberFromSize(length);
@@ skipping 11 matching lines @@
 
 
 // Initializes a typed array from an array-like object.
 // If an array-like object happens to be a typed array of the same type,
 // initializes backing store using memove.
 //
 // Returns true if backing store was initialized or false otherwise.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_TypedArrayInitializeFromArrayLike) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
-  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, holder, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, this_obj, 0);
   CONVERT_SMI_ARG_CHECKED(arrayId, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, source, 2);
   CONVERT_ARG_HANDLE_CHECKED(Object, length_obj, 3);
 
+  ExternalArrayType array_type = kExternalByteArray;  // Bogus initialization.
+  size_t element_size = 1;  // Bogus initialization.
+  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size);
+
+  if (!this_obj->IsJSTypedArray()) {
+    return ThrowTypeError(isolate, "constructor_not_function",
+                          GetTypedArrayName(arrayId));
+  }
+  Handle<JSTypedArray> holder(JSTypedArray::cast(*this_obj));
+  if (!holder->buffer()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", GetTypedArrayName(arrayId));
+  }
+
   ASSERT(holder->GetInternalFieldCount() ==
       v8::ArrayBufferView::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBufferView::kInternalFieldCount; i++) {
     holder->SetInternalField(i, Smi::FromInt(0));
   }
 
-  ExternalArrayType array_type = kExternalByteArray;  // Bogus initialization.
-  size_t element_size = 1;  // Bogus initialization.
-  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size);
-
   Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
   size_t length = NumberToSize(isolate, *length_obj);
   size_t byte_length = length * element_size;
   if (byte_length < length) {  // Overflow
     return isolate->Throw(*isolate->factory()->
           NewRangeError("invalid_array_buffer_length",
             HandleVector<Object>(NULL, 0)));
   }
 
   // We assume that the caller of this function will initialize holder
@@ skipping 138 matching lines @@
     return Smi::FromInt(TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING);
   } else {  // Non-overlapping typed arrays
     return Smi::FromInt(TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING);
   }
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_DataViewInitialize) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
-  CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, this_obj, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, buffer, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, byte_offset, 2);
   CONVERT_ARG_HANDLE_CHECKED(Object, byte_length, 3);
 
+  if (!this_obj->IsJSDataView()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "DataView");
+  }
+  Handle<JSDataView> holder(JSDataView::cast(*this_obj));
+  if (!holder->buffer()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", "DataView");
+  }
+
   ASSERT(holder->GetInternalFieldCount() ==
       v8::ArrayBufferView::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBufferView::kInternalFieldCount; i++) {
     holder->SetInternalField(i, Smi::FromInt(0));
   }
 
   holder->set_buffer(*buffer);
   ASSERT(byte_offset->IsNumber());
   ASSERT(
       NumberToSize(isolate, buffer->byte_length()) >=
@@ skipping 247 matching lines @@
 DATA_VIEW_SETTER(Int8, int8_t)
 DATA_VIEW_SETTER(Uint16, uint16_t)
 DATA_VIEW_SETTER(Int16, int16_t)
 DATA_VIEW_SETTER(Uint32, uint32_t)
 DATA_VIEW_SETTER(Int32, int32_t)
 DATA_VIEW_SETTER(Float32, float)
 DATA_VIEW_SETTER(Float64, double)
 
 #undef DATA_VIEW_SETTER
 
+RUNTIME_FUNCTION(MaybeObject*, Runtime_SetInitialize) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, holder, 0);
+  if (!holder->IsJSSet()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "Set");
+  }
+  Handle<JSSet> set(JSSet::cast(*holder));
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_SetInitialize) {
+  if (!set->table()->IsUndefined()) {
+    return ThrowTypeError(isolate, "object_already_initialized", "Set");
+  }
+
+  Handle<ObjectHashSet> table = isolate->factory()->NewObjectHashSet(0);
+  set->set_table(*table);
+  return *holder;
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_SetClear) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
   Handle<ObjectHashSet> table = isolate->factory()->NewObjectHashSet(0);
   holder->set_table(*table);
   return *holder;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_SetAdd) {
@@ skipping 35 matching lines @@
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
   Handle<ObjectHashSet> table(ObjectHashSet::cast(holder->table()));
   return Smi::FromInt(table->NumberOfElements());
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_MapInitialize) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, holder, 0);
+  if (!holder->IsJSMap()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "Map");
+  }
+  Handle<JSMap> map(JSMap::cast(*holder));
+
+  if (!map->table()->IsUndefined()) {
+    return ThrowTypeError(isolate, "object_already_initialized", "Map");
+  }
+
+  Handle<ObjectHashTable> table = isolate->factory()->NewObjectHashTable(0);
+  map->set_table(*table);
+  return *holder;
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_MapClear) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
-  Handle<ObjectHashTable> table = isolate->factory()->NewObjectHashTable(0);
+  Handle<ObjectHashSet> table = isolate->factory()->NewObjectHashSet(0);
   holder->set_table(*table);
   return *holder;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_MapGet) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
@@ skipping 53 matching lines @@
 static JSWeakCollection* WeakCollectionInitialize(Isolate* isolate,
     Handle<JSWeakCollection> weak_collection) {
   ASSERT(weak_collection->map()->inobject_properties() == 0);
   Handle<ObjectHashTable> table = isolate->factory()->NewObjectHashTable(0);
   weak_collection->set_table(*table);
   weak_collection->set_next(Smi::FromInt(0));
   return *weak_collection;
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_WeakCollectionInitialize) {
+RUNTIME_FUNCTION(MaybeObject*, Runtime_WeakMapInitialize) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, holder, 0);
+  if (!holder->IsJSWeakMap()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "WeakMap");
+  }
+  Handle<JSWeakMap> map(JSWeakMap::cast(*holder));
+  if (!map->table()->IsUndefined()) {
+    return ThrowTypeError(isolate, "object_already_initialized", "WeakMap");
+  }
+  return WeakCollectionInitialize(isolate, map);
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_WeakSetInitialize) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(Object, holder, 0);
+  if (!holder->IsJSWeakSet()) {
+    return ThrowTypeError(isolate, "constructor_not_function", "WeakSet");
+  }
+  Handle<JSWeakSet> set(JSWeakSet::cast(*holder));
+  if (!set->table()->IsUndefined()) {
+    return ThrowTypeError(isolate, "object_already_initialized", "WeakSet");
+  }
+  return WeakCollectionInitialize(isolate, set);
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_WeakCollectionClear) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, weak_collection, 0);
   return WeakCollectionInitialize(isolate, weak_collection);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_WeakCollectionGet) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
@@ skipping 12651 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal