[Arguments] Rename some identifiers.

src/objects.cc

 // Copyright 2011 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 2554 matching lines @@
   if (HasFastProperties()) return this;
   ASSERT(!IsGlobalObject());
   return property_dictionary()->
       TransformPropertiesToFastFor(this, unused_property_fields);
 }
 
 
 MaybeObject* JSObject::NormalizeElements() {
   ASSERT(!HasExternalArrayElements());
   // Find the backing store.
-  FixedArray* elements = FixedArray::cast(this->elements());
+  FixedArray* original = FixedArray::cast(elements());
   bool is_arguments =
-      (elements->map() == GetHeap()->non_strict_arguments_elements_map());
+      (original->map() == GetHeap()->non_strict_arguments_elements_map());
   if (is_arguments) {
-    elements = FixedArray::cast(elements->get(1));
+    original = FixedArray::cast(original->get(1));
   }
-  if (elements->IsDictionary()) return elements;
+  if (original->IsDictionary()) return original;
 
   ASSERT(HasFastElements() || HasFastArgumentsElements());
   // Compute the effective length and allocate a new backing store.
   int length = IsJSArray()
       ? Smi::cast(JSArray::cast(this)->length())->value()
-      : elements->length();
+      : original->length();
   NumberDictionary* dictionary = NULL;
   { Object* object;
     MaybeObject* maybe = NumberDictionary::Allocate(length);
     if (!maybe->ToObject(&object)) return maybe;
     dictionary = NumberDictionary::cast(object);
   }
 
   // Copy the elements to the new backing store.
   for (int i = 0; i < length; i++) {
-    Object* value = elements->get(i);
+    Object* value = original->get(i);
     if (!value->IsTheHole()) {
       PropertyDetails details = PropertyDetails(NONE, NORMAL);
       Object* new_dictionary;
-      MaybeObject* maybe =
-          dictionary->AddNumberEntry(i, elements->get(i), details);
+      MaybeObject* maybe = dictionary->AddNumberEntry(i, value, details);
       if (!maybe->ToObject(&new_dictionary)) return maybe;
       dictionary = NumberDictionary::cast(new_dictionary);
     }
   }
 
   // Switch to using the dictionary as the backing storage for elements.
   if (is_arguments) {
-    FixedArray::cast(this->elements())->set(1, dictionary);
+    FixedArray::cast(elements())->set(1, dictionary);
   } else {
     // Set the new map first to satify the elements type assert in
     // set_elements().
     Object* new_map;
     MaybeObject* maybe = map()->GetSlowElementsMap();
     if (!maybe->ToObject(&new_map)) return maybe;
     set_map(Map::cast(new_map));
     set_elements(dictionary);
   }
 
@@ skipping 128 matching lines @@
   MaybeObject* raw_result =
       this_handle->DeleteElementPostInterceptor(index, NORMAL_DELETION);
   RETURN_IF_SCHEDULED_EXCEPTION(isolate);
   return raw_result;
 }
 
 
 MaybeObject* JSObject::DeleteFastElement(uint32_t index) {
   ASSERT(HasFastElements() || HasFastArgumentsElements());
   Heap* heap = GetHeap();
-  FixedArray* elements = FixedArray::cast(this->elements());
-  if (elements->map() == heap->non_strict_arguments_elements_map()) {
-    elements = FixedArray::cast(elements->get(1));
+  FixedArray* backing_store = FixedArray::cast(elements());
+  if (backing_streo->map() == heap->non_strict_arguments_elements_map()) {

[Kevin Millikin (Chromium), 2011/03/30 12:02:45]

I'll commit the version that actually compiles.

+    backing_store = FixedArray::cast(backing_store->get(1));
   } else {
-    Object* object;
+    Object* writable;
     MaybeObject* maybe = EnsureWritableFastElements();
-    if (!maybe->ToObject(&object)) return maybe;
-    elements = FixedArray::cast(object);
+    if (!maybe->ToObject(&writable)) return maybe;
+    backing_store = FixedArray::cast(writable);
   }
   int length = IsJSArray()
       ? Smi::cast(JSArray::cast(this)->length())->value()
-      : elements->length();
+      : backing_store->length();
   if (index < static_cast<uint32_t>(length)) {
-    elements->set_the_hole(index);
+    backing_store->set_the_hole(index);
   }
   return heap->true_value();
 }
 
 
 MaybeObject* JSObject::DeleteDictionaryElement(uint32_t index,
                                                DeleteMode mode) {
   Isolate* isolate = GetIsolate();
   Heap* heap = isolate->heap();
-  FixedArray* elements = FixedArray::cast(this->elements());
-  if (elements->map() == heap->non_strict_arguments_elements_map()) {
-    elements = FixedArray::cast(elements->get(1));
+  FixedArray* backing_store = FixedArray::cast(elements());
+  if (backing_store->map() == heap->non_strict_arguments_elements_map()) {
+    backing_store = FixedArray::cast(backing_store->get(1));
   }
-  NumberDictionary* dictionary = NumberDictionary::cast(elements);
+  NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
   int entry = dictionary->FindEntry(index);
   if (entry != NumberDictionary::kNotFound) {
     Object* result = dictionary->DeleteProperty(entry, mode);
     if (mode == STRICT_DELETION && result == heap->false_value()) {
       // In strict mode, attempting to delete a non-configurable property
       // throws an exception.
       HandleScope scope(isolate);
       Handle<Object> name = isolate->factory()->NewNumberFromUint(index);
       Handle<Object> args[2] = { name, Handle<Object>(this) };
       Handle<Object> error =
@@ skipping 4696 matching lines @@
 
 // Adding n elements in fast case is O(n*n).
 // Note: revisit design to have dual undefined values to capture absent
 // elements.
 MaybeObject* JSObject::SetFastElement(uint32_t index,
                                       Object* value,
                                       StrictModeFlag strict_mode,
                                       bool check_prototype) {
   ASSERT(HasFastElements() || HasFastArgumentsElements());
 
-  FixedArray* elements = FixedArray::cast(this->elements());
-  if (elements->map() == GetHeap()->non_strict_arguments_elements_map()) {
-    elements = FixedArray::cast(elements->get(1));
+  FixedArray* backing_store = FixedArray::cast(elements());
+  if (backing_store->map() == GetHeap()->non_strict_arguments_elements_map()) {
+    backing_store = FixedArray::cast(backing_store->get(1));
   } else {
-    Object* object;
+    Object* writable;
     MaybeObject* maybe = EnsureWritableFastElements();
-    if (!maybe->ToObject(&object)) return maybe;
-    elements = FixedArray::cast(object);
+    if (!maybe->ToObject(&writable)) return maybe;
+    backing_store = FixedArray::cast(writable);
   }
-  uint32_t length = static_cast<uint32_t>(elements->length());
+  uint32_t length = static_cast<uint32_t>(backing_store->length());
 
   if (check_prototype &&
-      (index >= length || elements->get(index)->IsTheHole())) {
+      (index >= length || backing_store->get(index)->IsTheHole())) {
     bool found;
     MaybeObject* result =
         SetElementWithCallbackSetterInPrototypes(index, value, &found);
     if (found) return result;
   }
 
   // Check whether there is extra space in fixed array..
   if (index < length) {
-    elements->set(index, value);
+    backing_store->set(index, value);
     if (IsJSArray()) {
       // Update the length of the array if needed.
       uint32_t array_length = 0;
       CHECK(JSArray::cast(this)->length()->ToArrayIndex(&array_length));
       if (index >= array_length) {
         JSArray::cast(this)->set_length(Smi::FromInt(index + 1));
       }
     }
     return value;
   }
@@ skipping 521 matching lines @@
       break;
   }
   return GetHeap()->undefined_value();
 }
 
 
 bool JSObject::HasDenseElements() {
   int capacity = 0;
   int number_of_elements = 0;
 
-  FixedArray* elements = FixedArray::cast(this->elements());
+  FixedArray* backing_store = FixedArray::cast(elements());
   switch (GetElementsKind()) {
     case NON_STRICT_ARGUMENTS_ELEMENTS:
-      elements = FixedArray::cast(elements->get(1));
-      if (elements->IsDictionary()) {
-        NumberDictionary* dictionary = NumberDictionary::cast(elements);
+      backing_store = FixedArray::cast(backing_store->get(1));
+      if (backing_store->IsDictionary()) {
+        NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
         capacity = dictionary->Capacity();
         number_of_elements = dictionary->NumberOfElements();
         break;
       }
       // Fall through.
     case FAST_ELEMENTS:
-      capacity = elements->length();
+      capacity = backing_store->length();
       for (int i = 0; i < capacity; ++i) {
-        if (!elements->get(i)->IsTheHole()) ++number_of_elements;
+        if (!backing_store->get(i)->IsTheHole()) ++number_of_elements;
       }
       break;
     case DICTIONARY_ELEMENTS: {
-      NumberDictionary* dictionary = NumberDictionary::cast(elements);
+      NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
       capacity = dictionary->Capacity();
       number_of_elements = dictionary->NumberOfElements();
       break;
     }
     case EXTERNAL_PIXEL_ELEMENTS:
     case EXTERNAL_BYTE_ELEMENTS:
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
     case EXTERNAL_SHORT_ELEMENTS:
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
     case EXTERNAL_INT_ELEMENTS:
     case EXTERNAL_UNSIGNED_INT_ELEMENTS:
     case EXTERNAL_FLOAT_ELEMENTS:
       return true;
   }
 
   return (capacity == 0) || (number_of_elements > (capacity / 2));
 }
 
 
 bool JSObject::ShouldConvertToSlowElements(int new_capacity) {
   ASSERT(HasFastElements());
   // Keep the array in fast case if the current backing storage is
   // almost filled and if the new capacity is no more than twice the
   // old capacity.
-  FixedArray* elements = FixedArray::cast(this->elements());
-  if (elements->map() == GetHeap()->non_strict_arguments_elements_map()) {
-    elements = FixedArray::cast(elements->get(1));
+  FixedArray* backing_store = FixedArray::cast(elements());
+  if (backing_store->map() == GetHeap()->non_strict_arguments_elements_map()) {
+    backing_store = FixedArray::cast(backing_store->get(1));
   }
-  return !HasDenseElements() || ((new_capacity / 2) > elements->length());
+  return !HasDenseElements() || ((new_capacity / 2) > backing_store->length());
 }
 
 
 bool JSObject::ShouldConvertToFastElements() {
   ASSERT(HasDictionaryElements() || HasDictionaryArgumentsElements());
   // If the elements are sparse, we should not go back to fast case.
   if (!HasDenseElements()) return false;
   // An object requiring access checks is never allowed to have fast
   // elements.  If it had fast elements we would skip security checks.
   if (IsAccessCheckNeeded()) return false;
@@ skipping 2470 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal