[es6] Better support for built-ins subclassing.

src/objects.cc

 // 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.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 11746 matching lines @@
   // suggested by the function.
   InstanceType instance_type;
   int instance_size;
   int in_object_properties;
   if (function->shared()->is_generator()) {
     instance_type = JS_GENERATOR_OBJECT_TYPE;
     instance_size = JSGeneratorObject::kSize;
     in_object_properties = 0;
   } else {
     instance_type = JS_OBJECT_TYPE;
-    instance_size = function->shared()->CalculateInstanceSize();
-    in_object_properties = function->shared()->CalculateInObjectProperties();
+    instance_size = function->shared()->CalculateInstanceSize(instance_type);
+    in_object_properties =
+        function->shared()->CalculateInObjectProperties(instance_type);
   }
   Handle<Map> map = isolate->factory()->NewMap(instance_type, instance_size);
   if (function->map()->is_strong()) {
     map->set_is_strong();
   }
 
   // Fetch or allocate prototype.
   Handle<Object> prototype;
   if (function->has_instance_prototype()) {
     prototype = handle(function->instance_prototype(), isolate);
   } else {
     prototype = isolate->factory()->NewFunctionPrototype(function);
   }
   map->SetInObjectProperties(in_object_properties);
   map->set_unused_property_fields(in_object_properties);
   DCHECK(map->has_fast_object_elements());
 
   // Finally link initial map and constructor function.
   DCHECK(prototype->IsJSReceiver());
   JSFunction::SetInitialMap(function, map, prototype);
 
   if (!function->shared()->is_generator()) {
     function->StartInobjectSlackTracking();
   }
 }
 
 
+Handle<Map> JSFunction::EnsureDerivedHasInitialMap(
+    Handle<JSFunction> original_constructor, Handle<JSFunction> constructor) {
+  DCHECK(constructor->has_initial_map());
+  Isolate* isolate = constructor->GetIsolate();
+  Handle<Map> constructor_initial_map(constructor->initial_map(), isolate);
+  if (*original_constructor == *constructor) return constructor_initial_map;
+  if (original_constructor->has_initial_map()) {
+    // Check that |original_constructor|'s initial map still in sync with
+    // the |constructor|, otherwise we must create a new initial map for
+    // |original_constructor|.
+    if (original_constructor->initial_map()->GetConstructor() == *constructor) {
+      return handle(original_constructor->initial_map(), isolate);
+    }
+  }
+
+  // First create a new map with the size and number of in-object properties
+  // suggested by the function.
+  DCHECK(!original_constructor->shared()->is_generator());
+  DCHECK(!constructor->shared()->is_generator());
+
+  Handle<Map> map =
+      Map::Copy(constructor_initial_map, "EnsureDerivedHasInitialMap");
+
+  // Fetch or allocate prototype.
+  Handle<Object> prototype;
+  if (original_constructor->has_instance_prototype()) {
+    prototype = handle(original_constructor->instance_prototype(), isolate);
+  } else {
+    prototype = isolate->factory()->NewFunctionPrototype(original_constructor);
+  }
+
+  DCHECK(prototype->IsJSReceiver());
+  if (map->prototype() != *prototype) {
+    Map::SetPrototype(map, prototype, FAST_PROTOTYPE);
+  }
+
+  // Finally link initial map and constructor function if the original
+  // constructor is actually a subclass constructor.
+  if (IsSubclassConstructor(original_constructor->shared()->kind())) {
+    InstanceType instance_type = map->instance_type();
+    int instance_size =
+        original_constructor->shared()->CalculateInstanceSize(instance_type);
+    map->set_instance_size(instance_size);
+
+    int in_object_properties =
+        original_constructor->shared()->CalculateInObjectProperties(

[Toon Verwaest, 2015/10/26 15:10:57]

Shouldn't we add up the expected number of properties (expected_nof_properties)
from the entire class hierarchy? I guess we need a
"CalculateInstanceSizeForDerivedClass".

[Igor Sheludko, 2015/10/27 12:56:12]

Done.

+            instance_type);
+    map->SetInObjectProperties(in_object_properties);
+    map->set_unused_property_fields(in_object_properties);
+
+    JSFunction::SetInitialMap(original_constructor, map, prototype);
+    map->SetConstructor(*constructor);
+    original_constructor->StartInobjectSlackTracking();
+  } else {
+    map->SetConstructor(*constructor);
+  }
+  return map;
+}
+
+
 void JSFunction::SetInstanceClassName(String* name) {
   shared()->set_instance_class_name(name);
 }
 
 
 void JSFunction::PrintName(FILE* out) {
   base::SmartArrayPointer<char> name = shared()->DebugName()->ToCString();
   PrintF(out, "%s", name.get());
 }
 
@@ skipping 295 matching lines @@
   if (!script()->IsScript()) return false;
   return !optimization_disabled();
 }
 
 
 int SharedFunctionInfo::SourceSize() {
   return end_position() - start_position();
 }
 
 
-int SharedFunctionInfo::CalculateInstanceSize() {
-  int instance_size =
-      JSObject::kHeaderSize +
-      expected_nof_properties() * kPointerSize;
+int SharedFunctionInfo::CalculateInstanceSize(InstanceType instance_type) {
+  int header_size = JSObject::GetHeaderWithInternalFieldsSize(instance_type);
+  int instance_size = header_size + expected_nof_properties() * kPointerSize;
   if (instance_size > JSObject::kMaxInstanceSize) {
     instance_size = JSObject::kMaxInstanceSize;
   }
   return instance_size;
 }
 
 
-int SharedFunctionInfo::CalculateInObjectProperties() {
-  return (CalculateInstanceSize() - JSObject::kHeaderSize) / kPointerSize;
+int SharedFunctionInfo::CalculateInObjectProperties(
+    InstanceType instance_type) {
+  int header_size = JSObject::GetHeaderWithInternalFieldsSize(instance_type);
+  return (CalculateInstanceSize(instance_type) - header_size) / kPointerSize;
 }
 
 
 // Output the source code without any allocation in the heap.
 std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v) {
   const SharedFunctionInfo* s = v.value;
   // For some native functions there is no source.
   if (!s->HasSourceCode()) return os << "<No Source>";
 
   // Get the source for the script which this function came from.
@@ skipping 5624 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8