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, const char** name) {
   switch (arrayId) {
     case ARRAY_ID_UINT8:
       *array_type = kExternalUnsignedByteArray;
       *element_size = 1;
+      *name = "Uint8Array";
       break;
     case ARRAY_ID_INT8:
       *array_type = kExternalByteArray;
       *element_size = 1;
+      *name = "Int8Array";
       break;
     case ARRAY_ID_UINT16:
       *array_type = kExternalUnsignedShortArray;
       *element_size = 2;
+      *name = "Uint16Array";
       break;
     case ARRAY_ID_INT16:
       *array_type = kExternalShortArray;
       *element_size = 2;
+      *name = "Int16Array";
       break;
     case ARRAY_ID_UINT32:
       *array_type = kExternalUnsignedIntArray;
       *element_size = 4;
+      *name = "Uint32Array";
       break;
     case ARRAY_ID_INT32:
       *array_type = kExternalIntArray;
       *element_size = 4;
+      *name = "Int32Array";
       break;
     case ARRAY_ID_FLOAT32:
       *array_type = kExternalFloatArray;
       *element_size = 4;
+      *name = "Float32Array";
       break;
     case ARRAY_ID_FLOAT64:
       *array_type = kExternalDoubleArray;
       *element_size = 8;
+      *name = "Float64Array";
       break;
     case ARRAY_ID_UINT8C:
       *array_type = kExternalPixelArray;
       *element_size = 1;
+      *name = "Uint8ClampedArray";
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 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.
+  const char* name = NULL;  // Bogus initialization.
+  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size, &name);

[arv (Not doing code reviews), 2013/08/04 16:44:28]

Can you move this code into the error cases? The common case is that there is no
error and we can skip all this extra work just to get the name that we are not
going to use.

[Dmitry Lomov (no reviews), 2013/08/05 10:15:22]

Done. Do you think it's cleaner that way? (Perf impact is non-existent of
course)

[arv (Not doing code reviews), 2013/08/05 13:34:33]

Sorry, I think my comment was bad advice. I didn't realize that this work needs
to be done in the common case anyway. Adding the name will be lost in the noise.
I didn't realize how much work is done on initialization anyway.

I'll let you determine which way you prefer. The old way is definitely cleaner.

+
+  if (!this_obj->IsJSTypedArray()) {
+    return ThrowTypeError(isolate, "constructor_not_function", name);
+  }
+  Handle<JSTypedArray> holder(JSTypedArray::cast(*this_obj));
+  if (!holder->buffer()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", name);
+  }
+
   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.
+  const char* name = NULL;  // Bogus initialization.
+  ArrayIdToTypeAndSize(arrayId, &array_type, &element_size, &name);

[arv (Not doing code reviews), 2013/08/04 16:44:28]

Ditto

[Dmitry Lomov (no reviews), 2013/08/05 10:15:22]

Ditto :)

+
+  if (!this_obj->IsJSTypedArray()) {
+    return ThrowTypeError(isolate, "constructor_not_function", name);
+  }
+  Handle<JSTypedArray> holder(JSTypedArray::cast(*this_obj));
+  if (!holder->buffer()->IsUndefined()) {
+    return ThrowTypeError(
+        isolate, "object_already_initialized", name);
+  }
+
   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