Couple the enumeration index of a property to the size of the descriptor array where it first appea…

src/bootstrapper.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 376 matching lines @@
   Handle<DescriptorArray> descriptors(factory()->NewDescriptorArray(size));
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   DescriptorArray::WhitenessWitness witness(*descriptors);
 
   int index = 0;
 
   {  // Add length.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionLength));
-    CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add name.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionName));
-    CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add arguments.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionArguments));
-    CallbacksDescriptor d(
-        *factory()->arguments_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->arguments_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add caller.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionCaller));
-    CallbacksDescriptor d(*factory()->caller_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->caller_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     // Add prototype.
     if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
       attribs = static_cast<PropertyAttributes>(attribs & ~READ_ONLY);
     }
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionPrototype));
-    CallbacksDescriptor d(
-        *factory()->prototype_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
+    CallbacksDescriptor d(*factory()->prototype_symbol(), *f, attribs);
+    descriptors->Append(index, &d, witness);
   }
 
   descriptors->Sort(witness);
   return descriptors;
 }
 
 
 Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
   Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
   Handle<DescriptorArray> descriptors =
@@ skipping 99 matching lines @@
   int size = (prototypeMode == DONT_ADD_PROTOTYPE) ? 4 : 5;
   Handle<DescriptorArray> descriptors(factory()->NewDescriptorArray(size));
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE);
 
   DescriptorArray::WhitenessWitness witness(*descriptors);
 
   int index = 0;
   {  // Add length.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionLength));
-    CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add name.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionName));
-    CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add arguments.
     Handle<AccessorPair> arguments(factory()->NewAccessorPair());
-    CallbacksDescriptor d(
-        *factory()->arguments_symbol(), *arguments, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->arguments_symbol(), *arguments, attribs);
+    descriptors->Append(index++, &d, witness);
   }
   {  // Add caller.
     Handle<AccessorPair> caller(factory()->NewAccessorPair());
-    CallbacksDescriptor d(
-        *factory()->caller_symbol(), *caller, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
-    ++index;
+    CallbacksDescriptor d(*factory()->caller_symbol(), *caller, attribs);
+    descriptors->Append(index++, &d, witness);
   }
 
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     // Add prototype.
     if (prototypeMode != ADD_WRITEABLE_PROTOTYPE) {
       attribs = static_cast<PropertyAttributes>(attribs | READ_ONLY);
     }
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionPrototype));
-    CallbacksDescriptor d(
-        *factory()->prototype_symbol(), *f, attribs, index + 1);
-    descriptors->Set(index, &d, witness);
+    CallbacksDescriptor d(*factory()->prototype_symbol(), *f, attribs);
+    descriptors->Append(index, &d, witness);
   }
 
   descriptors->Sort(witness);
   return descriptors;
 }
 
 
 // ECMAScript 5th Edition, 13.2.3
 Handle<JSFunction> Genesis::GetThrowTypeErrorFunction() {
   if (throw_type_error_function.is_null()) {
@@ skipping 373 matching lines @@
 
     Handle<DescriptorArray> descriptors = factory->NewDescriptorArray(5);
     DescriptorArray::WhitenessWitness witness(*descriptors);
     PropertyAttributes final =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
     int index = 0;
     {
       // ECMA-262, section 15.10.7.1.
       FieldDescriptor field(heap->source_symbol(),
                             JSRegExp::kSourceFieldIndex,
-                            final,
-                            index + 1);
-      descriptors->Set(index, &field, witness);
-      ++index;
+                            final);
+      descriptors->Append(index++, &field, witness);
     }
     {
       // ECMA-262, section 15.10.7.2.
       FieldDescriptor field(heap->global_symbol(),
                             JSRegExp::kGlobalFieldIndex,
-                            final,
-                            index + 1);
-      descriptors->Set(index, &field, witness);
-      ++index;
+                            final);
+      descriptors->Append(index++, &field, witness);
     }
     {
       // ECMA-262, section 15.10.7.3.
       FieldDescriptor field(heap->ignore_case_symbol(),
                             JSRegExp::kIgnoreCaseFieldIndex,
-                            final,
-                            index + 1);
-      descriptors->Set(index, &field, witness);
-      ++index;
+                            final);
+      descriptors->Append(index++, &field, witness);
     }
     {
       // ECMA-262, section 15.10.7.4.
       FieldDescriptor field(heap->multiline_symbol(),
                             JSRegExp::kMultilineFieldIndex,
-                            final,
-                            index + 1);
-      descriptors->Set(index, &field, witness);
-      ++index;
+                            final);
+      descriptors->Append(index++, &field, witness);
     }
     {
       // ECMA-262, section 15.10.7.5.
       PropertyAttributes writable =
           static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
       FieldDescriptor field(heap->last_index_symbol(),
                             JSRegExp::kLastIndexFieldIndex,
-                            writable,
-                            index + 1);
-      descriptors->Set(index, &field, witness);
+                            writable);
+      descriptors->Append(index, &field, witness);
     }
     descriptors->Sort(witness);
 
     initial_map->set_inobject_properties(5);
     initial_map->set_pre_allocated_property_fields(5);
     initial_map->set_unused_property_fields(0);
     initial_map->set_instance_size(
         initial_map->instance_size() + 5 * kPointerSize);
     initial_map->set_instance_descriptors(*descriptors);
     initial_map->set_visitor_id(StaticVisitorBase::GetVisitorId(*initial_map));
@@ skipping 127 matching lines @@
     callee->set_getter(*throw_function);
     callee->set_setter(*throw_function);
     caller->set_getter(*throw_function);
     caller->set_setter(*throw_function);
 
     // Create the descriptor array for the arguments object.
     Handle<DescriptorArray> descriptors = factory->NewDescriptorArray(3);
     DescriptorArray::WhitenessWitness witness(*descriptors);
     int index = 0;
     {  // length
-      FieldDescriptor d(*factory->length_symbol(), 0, DONT_ENUM, index + 1);
-      descriptors->Set(index, &d, witness);
-      ++index;
+      FieldDescriptor d(*factory->length_symbol(), 0, DONT_ENUM);
+      descriptors->Append(index++, &d, witness);
     }
     {  // callee
       CallbacksDescriptor d(*factory->callee_symbol(),
                             *callee,
-                            attributes,
-                            index + 1);
-      descriptors->Set(index, &d, witness);
-      ++index;
+                            attributes);
+      descriptors->Append(index++, &d, witness);
     }
     {  // caller
       CallbacksDescriptor d(*factory->caller_symbol(),
                             *caller,
-                            attributes,
-                            index + 1);
-      descriptors->Set(index, &d, witness);
+                            attributes);
+      descriptors->Append(index++, &d, witness);
     }
     descriptors->Sort(witness);
 
     // Create the map. Allocate one in-object field for length.
     Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE,
                                       Heap::kArgumentsObjectSizeStrict);
     map->set_instance_descriptors(*descriptors);
     map->set_function_with_prototype(true);
     map->set_prototype(global_context()->object_function()->prototype());
     map->set_pre_allocated_property_fields(1);
@@ skipping 581 matching lines @@
         array_function->initial_map()->instance_descriptors());
     int old = array_descriptors->SearchWithCache(heap()->length_symbol());
     MaybeObject* copy_result =
         reresult_descriptors->CopyFrom(0, *array_descriptors, old, witness);
     if (copy_result->IsFailure()) return false;
 
     int index = 1;
     {
       FieldDescriptor index_field(heap()->index_symbol(),
                                   JSRegExpResult::kIndexIndex,
-                                  NONE,
-                                  index + 1);
-      reresult_descriptors->Set(index, &index_field, witness);
-      ++index;
+                                  NONE);
+      reresult_descriptors->Append(index++, &index_field, witness);
     }
 
     {
       FieldDescriptor input_field(heap()->input_symbol(),
                                   JSRegExpResult::kInputIndex,
-                                  NONE,
-                                  index + 1);
-      reresult_descriptors->Set(index, &input_field, witness);
+                                  NONE);
+      reresult_descriptors->Append(index, &input_field, witness);
     }
     reresult_descriptors->Sort(witness);
 
     initial_map->set_inobject_properties(2);
     initial_map->set_pre_allocated_property_fields(2);
     initial_map->set_unused_property_fields(0);
     initial_map->set_instance_descriptors(*reresult_descriptors);
 
     global_context()->set_regexp_result_map(*initial_map);
   }
@@ skipping 585 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal