[runtime] Fix class literal boilerplates

Bug: chromium:802040
Change-Id: I887a6e9d06bd1e66e0e8175a7bbb830f693e55ed
Reviewed-on: https://chromium-review.googlesource.com/866854Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Camillo Bruni <cbruni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#50589}

src/objects/literal-objects.cc

@@ -278,10 +278,12 @@ class ObjectDescriptor {
   void IncPropertiesCount() { ++property_count_; }
   void IncElementsCount() { ++element_count_; }
 
-  bool has_computed_properties() const { return computed_count_ != 0; }
+  bool HasDictionaryProperties() const {
+    return computed_count_ > 0 || property_count_ > kMaxNumberOfDescriptors;
+  }
 
   Handle<Object> properties_template() const {
-    return has_computed_properties()
+    return HasDictionaryProperties()
                ? Handle<Object>::cast(properties_dictionary_template_)
                : Handle<Object>::cast(descriptor_array_template_);
   }
@@ -298,8 +300,8 @@ class ObjectDescriptor {
     Factory* factory = isolate->factory();
     descriptor_array_template_ = factory->empty_descriptor_array();
     properties_dictionary_template_ = factory->empty_property_dictionary();
-    if (property_count_ || has_computed_properties() || slack) {
-      if (has_computed_properties()) {
+    if (property_count_ || HasDictionaryProperties() || slack) {
+      if (HasDictionaryProperties()) {
         properties_dictionary_template_ = NameDictionary::New(
             isolate, property_count_ + computed_count_ + slack);
       } else {
@@ -325,7 +327,7 @@ class ObjectDescriptor {
                    PropertyAttributes attribs) {
     bool is_accessor = value->IsAccessorInfo();
     DCHECK(!value->IsAccessorPair());
-    if (has_computed_properties()) {
+    if (HasDictionaryProperties()) {
       PropertyKind kind = is_accessor ? i::kAccessor : i::kData;
       PropertyDetails details(kind, attribs, PropertyCellType::kNoCell,
                               next_enumeration_index_++);
@@ -344,7 +346,7 @@ class ObjectDescriptor {
                         ClassBoilerplate::ValueKind value_kind,
                         int value_index) {
     Smi* value = Smi::FromInt(value_index);
-    if (has_computed_properties()) {
+    if (HasDictionaryProperties()) {
       UpdateNextEnumerationIndex(value_index);
       AddToDictionaryTemplate(isolate, properties_dictionary_template_, name,
                               value_index, value_kind, value);
@@ -378,7 +380,7 @@ class ObjectDescriptor {
   }
 
   void Finalize(Isolate* isolate) {
-    if (has_computed_properties()) {
+    if (HasDictionaryProperties()) {
       properties_dictionary_template_->SetNextEnumerationIndex(
           next_enumeration_index_);
 
@@ -540,7 +542,7 @@ Handle<ClassBoilerplate> ClassBoilerplate::BuildClassBoilerplate(
   bool install_class_name_accessor = false;
   if (!expr->has_name_static_property() &&
       expr->constructor()->has_shared_name()) {
-    if (static_desc.has_computed_properties()) {
+    if (static_desc.HasDictionaryProperties()) {
       // Install class name accessor if necessary during class literal
       // instantiation.
       install_class_name_accessor = true;

src/objects/map.h

@@ -270,6 +270,8 @@ class Map : public HeapObject {
   DEFINE_BIT_FIELDS(MAP_BIT_FIELD3_FIELDS)
 #undef MAP_BIT_FIELD3_FIELDS
 
+  STATIC_ASSERT(NumberOfOwnDescriptorsBits::kMax >= kMaxNumberOfDescriptors);
+
   static const int kSlackTrackingCounterStart = 7;
   static const int kSlackTrackingCounterEnd = 1;
   static const int kNoSlackTracking = 0;

test/mjsunit/es6/classes.js

@@ -1086,3 +1086,103 @@ function testClassRestrictedProperties(C) {
   assertEquals(42, usingYieldInExtends());
 
 })();
+
+
+(function testLargeClassesMethods() {
+  const kLimit = 2000;
+  let evalString = "(function(i) { " +
+      "let clazz = class { " +
+      "   constructor(i) { this.value = i; } ";
+  for (let i = 0; i < 2000; i++) {
+    evalString  += "property"+i+"() { return "+i+"; }; "
+  }
+  evalString += "};" +
+      " return new clazz(i); })";
+
+  let fn = eval(evalString);
+  assertEquals(fn(1).value, 1);
+  assertEquals(fn(2).value, 2);
+  assertEquals(fn(3).value, 3);
+  %OptimizeFunctionOnNextCall(fn);
+  assertEquals(fn(4).value, 4);
+
+  let instance = fn(1);
+  assertEquals(Object.getOwnPropertyNames(instance).length, 1);
+  assertEquals(Object.getOwnPropertyNames(instance.__proto__).length,
+      kLimit + 1);
+
+  // Call all instance functions.
+  for (let i = 0; i < kLimit; i++) {
+    const key = "property" + i;
+    assertEquals(instance[key](), i);
+  }
+})();
+
+
+(function testLargeClassesStaticMethods() {
+  const kLimit = 2000;
+  let evalString = "(function(i) { " +
+      "let clazz = class { " +
+      "   constructor(i) { this.value = i; } ";
+  for (let i = 0; i < kLimit; i++) {
+    evalString  += "static property"+i+"() { return "+i+" }; "
+  }
+  evalString += "};" +
+      " return new clazz(i); })";
+
+  let fn = eval(evalString);
+
+  assertEquals(fn(1).value, 1);
+  assertEquals(fn(2).value, 2);
+  assertEquals(fn(3).value, 3);
+  %OptimizeFunctionOnNextCall(fn);
+  assertEquals(fn(4).value, 4);
+
+  let instance = fn(1);
+  assertEquals(Object.getOwnPropertyNames(instance).length, 1);
+  assertEquals(instance.value, 1);
+  instance.value = 10;
+  assertEquals(instance.value, 10);
+
+  // kLimit + nof default properties (length, prototype, name).
+  assertEquals(Object.getOwnPropertyNames(instance.constructor).length,
+      kLimit + 3);
+
+  // Call all static properties.
+  for (let i = 0; i < kLimit; i++) {
+    const key = "property" + i;
+    assertEquals(instance.constructor[key](), i);
+  }
+})();
+
+
+(function testLargeClassesProperties(){
+  const kLimit = 2000;
+  let evalString = "(function(i) { " +
+      "let clazz = class { " +
+      "   constructor(i) { this.value = i;";
+  for (let i = 0; i < kLimit ; i++) {
+    evalString  += "this.property"+i +" = "+i+"; "
+  }
+  evalString += "}};" +
+      " return (new clazz(i)); })";
+
+  let fn = eval(evalString);
+  assertEquals(fn(1).value, 1);
+  assertEquals(fn(2).value, 2);
+  assertEquals(fn(3).value, 3);
+  %OptimizeFunctionOnNextCall(fn);
+  assertEquals(fn(4).value, 4);
+
+  let instance = fn(1);
+  assertEquals(Object.getOwnPropertyNames(instance).length, kLimit+1);
+
+  // Get and set all properties.
+  for (let i = 0; i < kLimit; i++) {
+    const key = "property" + i;
+    assertEquals(instance[key], i);
+    const value = "value"+i;
+    instance[key] = value;
+    assertEquals(instance[key], value);
+  }
+})();