[runtime] Allocate space for computed property names

src/ast/ast.cc

 // Copyright 2012 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/ast/ast.h"
 
 #include <cmath>  // For isfinite.
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 564 matching lines @@
       (max_element_index <= 32) || ((2 * elements) >= max_element_index));
   bit_field_ = HasElementsField::update(bit_field_, elements > 0);
 
   set_is_simple(is_simple);
   set_depth(depth_acc);
 }
 
 void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
   if (!constant_properties_.is_null()) return;
 
-  // Allocate a fixed array to hold all the constant properties.
-  Handle<FixedArray> constant_properties =
-      isolate->factory()->NewFixedArray(boilerplate_properties_ * 2, TENURED);
+  // Allocate a fixed array to hold all the constant properties and the number
+  // of total properties.
+  Handle<FixedArray> constant_properties = isolate->factory()->NewFixedArray(

[Toon Verwaest, 2017/01/18 08:49:53]

Handle<ConstantProperties> =
isolate->factory()->NewConstantProperties(properties()->length(),
boilerplate_properties_);

which does 

size = boilerplate_properties * 2;
if (properties != boilerplate_properties) size++;
Handle<ConstantProperties> constant_properties =
Handle<ConstantProperties>::cast(NewFixedArray(size));
if (properties != boilerplate_properties) {
  constant_properties->set_property_count(properties);
}
return constant_properties;

[Franzi, 2017/01/18 14:23:10]

Acknowledged.

+      boilerplate_properties_ * 2 + 1, TENURED);
 
   int position = 0;
   for (int i = 0; i < properties()->length(); i++) {
     ObjectLiteral::Property* property = properties()->at(i);
     if (!IsBoilerplateProperty(property)) {
       continue;
     }
 
     if (static_cast<uint32_t>(position) == boilerplate_properties_ * 2) {
       DCHECK(property->is_computed_name());
@@ skipping 17 matching lines @@
       key = isolate->factory()->NewNumberFromUint(element_index);
     } else if (key->IsNumber() && !key->ToArrayIndex(&element_index)) {
       key = isolate->factory()->NumberToString(key);
     }
 
     // Add name, value pair to the fixed array.
     constant_properties->set(position++, *key);
     constant_properties->set(position++, *value);
   }
 
+  Handle<Object> total_properties =
+      isolate->factory()->NewNumberFromInt(total_properties_);

[gsathya, 2017/01/17 18:31:39]

total_properties_ can be calculated using the above for loop right? then we
don't need this to be a property of ObjectLiteral

[Franzi, 2017/01/17 19:08:45]

The loop breaks on the first computed property, and I'd have to do the rest of
the iteration to count all boilerplate properties. Is that better than an extra
field in ObjectLiteral?

[Toon Verwaest, 2017/01/18 08:49:53]

I think what he means is that DCHECK_EQ(total_properties_,
properties()->length()); in which case we don't need a separate
total_properties_ field on the ast node (we do need it in the fixed array
obviously).

[Franzi, 2017/01/18 14:23:10]

As discussed, it's not equal if __proto__ is present. I added a bit for
has_seen_proto as Sathya suggested. Dropped the total_properties. 

+  constant_properties->set(position, *total_properties);
+
   constant_properties_ = constant_properties;
 }
 
 bool ObjectLiteral::IsFastCloningSupported() const {
   // The FastCloneShallowObject builtin doesn't copy elements, and object
   // literals don't support copy-on-write (COW) elements for now.
   // TODO(mvstanton): make object literals support COW elements.
   return fast_elements() && has_shallow_properties() &&
          properties_count() <= ConstructorBuiltinsAssembler::
                                    kMaximumClonedShallowObjectProperties;
@@ skipping 402 matching lines @@
 // static
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 }  // namespace internal
 }  // namespace v8