/deps/v8/src/objects.cc - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/objects.cc

     #include "v8.h"
     #include "accessors.h"
     #include "allocation-site-scopes.h"
     #include "api.h"
     #include "arguments.h"
     #include "bootstrapper.h"
-...
+    }
     Handle<Object> Object::GetPropertyWithReceiver(
         Handle<Object> object,
         Handle<Object> receiver,
         Handle<Name> name,
         PropertyAttributes* attributes) {
       LookupResult lookup(name->GetIsolate());
       object->Lookup(*name, &lookup);
       Handle<Object> result =
           GetProperty(object, receiver, &lookup, name, attributes);
       ASSERT(*attributes <= ABSENT);
       return result;
+    }
     MaybeObject* Object::GetPropertyWithReceiver(Object* receiver,
                                                  Name* name,
                                                  PropertyAttributes* attributes) {
-...
+    }
     MaybeObject* JSObject::GetPropertyWithCallback(Object* receiver,
                                                    Object* structure,
                                                    Name* name) {
     Handle<FixedArray> JSObject::EnsureWritableFastElements(
         Handle<JSObject> object) {
       CALL_HEAP_FUNCTION(object->GetIsolate(),
                          object->EnsureWritableFastElements(),
                          FixedArray);
+    }
     Handle<Object> JSObject::GetPropertyWithCallback(Handle<JSObject> object,
                                                      Handle<Object> receiver,
                                                      Handle<Object> structure,
                                                      Handle<Name> name) {
       Isolate* isolate = name->GetIsolate();
       // To accommodate both the old and the new api we switch on the
       // data structure used to store the callbacks.  Eventually foreign
-...
       if (structure->IsForeign()) {
         AccessorDescriptor* callback =
             reinterpret_cast<AccessorDescriptor*>(
                 Foreign::cast(structure)->foreign_address());
         MaybeObject* value = (callback->getter)(isolate, receiver, callback->data);
         RETURN_IF_SCHEDULED_EXCEPTION(isolate);
         return value;
                 Handle<Foreign>::cast(structure)->foreign_address());
         CALL_HEAP_FUNCTION(isolate,
                            (callback->getter)(isolate, *receiver, callback->data),
                            Object);
+      }
       // api style callbacks.
       if (structure->IsAccessorInfo()) {
         if (!AccessorInfo::cast(structure)->IsCompatibleReceiver(receiver)) {
           Handle<Object> name_handle(name, isolate);
           Handle<Object> receiver_handle(receiver, isolate);
           Handle<Object> args[2] = { name_handle, receiver_handle };
         Handle<AccessorInfo> accessor_info = Handle<AccessorInfo>::cast(structure);
         if (!accessor_info->IsCompatibleReceiver(*receiver)) {
           Handle<Object> args[2] = { name, receiver };
           Handle<Object> error =
               isolate->factory()->NewTypeError("incompatible_method_receiver",
                                                HandleVector(args,
                                                             ARRAY_SIZE(args)));
           return isolate->Throw(*error);
           isolate->Throw(*error);
           return Handle<Object>::null();
+        }
         // TODO(rossberg): Handling symbols in the API requires changing the API,
         // so we do not support it for now.
         if (name->IsSymbol()) return isolate->heap()->undefined_value();
         if (name->IsSymbol()) return isolate->factory()->undefined_value();
         if (structure->IsDeclaredAccessorInfo()) {
           return GetDeclaredAccessorProperty(receiver,
                                              DeclaredAccessorInfo::cast(structure),
                                              isolate);
           CALL_HEAP_FUNCTION(
               isolate,
               GetDeclaredAccessorProperty(*receiver,
                                           DeclaredAccessorInfo::cast(*structure),
                                           isolate),
               Object);
+        }
         ExecutableAccessorInfo* data = ExecutableAccessorInfo::cast(structure);
         Object* fun_obj = data->getter();
         Handle<ExecutableAccessorInfo> data =
             Handle<ExecutableAccessorInfo>::cast(structure);
         v8::AccessorGetterCallback call_fun =
             v8::ToCData<v8::AccessorGetterCallback>(fun_obj);
         if (call_fun == NULL) return isolate->heap()->undefined_value();
             v8::ToCData<v8::AccessorGetterCallback>(data->getter());
         if (call_fun == NULL) return isolate->factory()->undefined_value();
         HandleScope scope(isolate);
         JSObject* self = JSObject::cast(receiver);
         Handle<String> key(String::cast(name));
         LOG(isolate, ApiNamedPropertyAccess("load", self, name));
         PropertyCallbackArguments args(isolate, data->data(), self, this);
         Handle<JSObject> self = Handle<JSObject>::cast(receiver);
         Handle<String> key = Handle<String>::cast(name);
         LOG(isolate, ApiNamedPropertyAccess("load", *self, *name));
         PropertyCallbackArguments args(isolate, data->data(), *self, *object);
         v8::Handle<v8::Value> result =
             args.Call(call_fun, v8::Utils::ToLocal(key));
         RETURN_IF_SCHEDULED_EXCEPTION(isolate);
         RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
         if (result.IsEmpty()) {
           return isolate->heap()->undefined_value();
           return isolate->factory()->undefined_value();
+        }
         Object* return_value = *v8::Utils::OpenHandle(*result);
         Handle<Object> return_value = v8::Utils::OpenHandle(*result);
         return_value->VerifyApiCallResultType();
         return return_value;
         return scope.CloseAndEscape(return_value);
+      }
       // __defineGetter__ callback
       if (structure->IsAccessorPair()) {
         Object* getter = AccessorPair::cast(structure)->getter();
         if (getter->IsSpecFunction()) {
           // TODO(rossberg): nicer would be to cast to some JSCallable here...
           return GetPropertyWithDefinedGetter(receiver, JSReceiver::cast(getter));
+        }
         // Getter is not a function.
         return isolate->heap()->undefined_value();
       Handle<Object> getter(Handle<AccessorPair>::cast(structure)->getter(),
                             isolate);
       if (getter->IsSpecFunction()) {
         // TODO(rossberg): nicer would be to cast to some JSCallable here...
         CALL_HEAP_FUNCTION(
             isolate,
             object->GetPropertyWithDefinedGetter(*receiver,
                                                  JSReceiver::cast(*getter)),
             Object);
+      }
       UNREACHABLE();
       return NULL;
       // Getter is not a function.
       return isolate->factory()->undefined_value();
+    }
-...
                                                   StrictModeFlag strict_mode) {
       Isolate* isolate = proxy->GetIsolate();
       Handle<String> name = isolate->factory()->Uint32ToString(index);
       CALL_HEAP_FUNCTION(isolate,
                          proxy->SetPropertyWithHandler(
                              *receiver, *name, *value, NONE, strict_mode),
                          Object);
       return SetPropertyWithHandler(
           proxy, receiver, name, value, NONE, strict_mode);
+    }
     bool JSProxy::HasElementWithHandler(uint32_t index) {
       String* name;
       MaybeObject* maybe = GetHeap()->Uint32ToString(index);
       if (!maybe->To<String>(&name)) return maybe;
       return HasPropertyWithHandler(name);
     bool JSProxy::HasElementWithHandler(Handle<JSProxy> proxy, uint32_t index) {
       Isolate* isolate = proxy->GetIsolate();
       Handle<String> name = isolate->factory()->Uint32ToString(index);
       return HasPropertyWithHandler(proxy, name);
+    }
-...
     // Only deal with CALLBACKS and INTERCEPTOR
     MaybeObject* JSObject::GetPropertyWithFailedAccessCheck(
         Object* receiver,
     Handle<Object> JSObject::GetPropertyWithFailedAccessCheck(
         Handle<JSObject> object,
         Handle<Object> receiver,
         LookupResult* result,
         Name* name,
         Handle<Name> name,
         PropertyAttributes* attributes) {
       Isolate* isolate = name->GetIsolate();
       if (result->IsProperty()) {
         switch (result->type()) {
           case CALLBACKS: {
             // Only allow API accessors.
             Object* obj = result->GetCallbackObject();
             if (obj->IsAccessorInfo()) {
               AccessorInfo* info = AccessorInfo::cast(obj);
               if (info->all_can_read()) {
                 *attributes = result->GetAttributes();
                 return result->holder()->GetPropertyWithCallback(
                     receiver, result->GetCallbackObject(), name);
+              }
             } else if (obj->IsAccessorPair()) {
               AccessorPair* pair = AccessorPair::cast(obj);
               if (pair->all_can_read()) {
                 return result->holder()->GetPropertyWithCallback(
                     receiver, result->GetCallbackObject(), name);
+              }
             Handle<Object> callback_obj(result->GetCallbackObject(), isolate);
             if (callback_obj->IsAccessorInfo()) {
               if (!AccessorInfo::cast(*callback_obj)->all_can_read()) break;
               *attributes = result->GetAttributes();
               // Fall through to GetPropertyWithCallback.
             } else if (callback_obj->IsAccessorPair()) {
               if (!AccessorPair::cast(*callback_obj)->all_can_read()) break;
               // Fall through to GetPropertyWithCallback.
             } else {
               break;
+            }
             break;
             Handle<JSObject> holder(result->holder(), isolate);
             return GetPropertyWithCallback(holder, receiver, callback_obj, name);
+          }
           case NORMAL:
           case FIELD:
           case CONSTANT: {
             // Search ALL_CAN_READ accessors in prototype chain.
             LookupResult r(GetIsolate());
             result->holder()->LookupRealNamedPropertyInPrototypes(name, &r);
             LookupResult r(isolate);
             result->holder()->LookupRealNamedPropertyInPrototypes(*name, &r);
             if (r.IsProperty()) {
               return GetPropertyWithFailedAccessCheck(receiver,
                                                       &r,
                                                       name,
                                                       attributes);
               return GetPropertyWithFailedAccessCheck(
                   object, receiver, &r, name, attributes);
+            }
             break;
+          }
           case INTERCEPTOR: {
             // If the object has an interceptor, try real named properties.
             // No access check in GetPropertyAttributeWithInterceptor.
             LookupResult r(GetIsolate());
             result->holder()->LookupRealNamedProperty(name, &r);
             LookupResult r(isolate);
             result->holder()->LookupRealNamedProperty(*name, &r);
             if (r.IsProperty()) {
               return GetPropertyWithFailedAccessCheck(receiver,
                                                       &r,
                                                       name,
                                                       attributes);
               return GetPropertyWithFailedAccessCheck(
                   object, receiver, &r, name, attributes);
+            }
             break;
+          }
-...
       // No accessible property found.
       *attributes = ABSENT;
       Heap* heap = name->GetHeap();
       Isolate* isolate = heap->isolate();
       isolate->ReportFailedAccessCheck(this, v8::ACCESS_GET);
       RETURN_IF_SCHEDULED_EXCEPTION(isolate);
       return heap->undefined_value();
       isolate->ReportFailedAccessCheck(*object, v8::ACCESS_GET);
       RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
       return isolate->factory()->undefined_value();
+    }
-...
+    }
     Handle<Object> JSObject::SetNormalizedProperty(Handle<JSObject> object,
                                                    LookupResult* result,
                                                    Handle<Object> value) {
       CALL_HEAP_FUNCTION(object->GetIsolate(),
                          object->SetNormalizedProperty(result, *value),
                          Object);
+    }
     MaybeObject* JSObject::SetNormalizedProperty(LookupResult* result,
                                                  Object* value) {
       ASSERT(!HasFastProperties());
       if (IsGlobalObject()) {
         PropertyCell* cell = PropertyCell::cast(
             property_dictionary()->ValueAt(result->GetDictionaryEntry()));
         MaybeObject* maybe_type = cell->SetValueInferType(value);
         if (maybe_type->IsFailure()) return maybe_type;
     void JSObject::SetNormalizedProperty(Handle<JSObject> object,
                                          LookupResult* result,
                                          Handle<Object> value) {
       ASSERT(!object->HasFastProperties());
       NameDictionary* property_dictionary = object->property_dictionary();
       if (object->IsGlobalObject()) {
         Handle<PropertyCell> cell(PropertyCell::cast(
             property_dictionary->ValueAt(result->GetDictionaryEntry())));
         PropertyCell::SetValueInferType(cell, value);
       } else {
         property_dictionary()->ValueAtPut(result->GetDictionaryEntry(), value);
         property_dictionary->ValueAtPut(result->GetDictionaryEntry(), *value);
+      }
       return value;
+    }
     Handle<Object> JSObject::SetNormalizedProperty(Handle<JSObject> object,
                                                    Handle<Name> key,
                                                    Handle<Object> value,
                                                    PropertyDetails details) {
       CALL_HEAP_FUNCTION(object->GetIsolate(),
                          object->SetNormalizedProperty(*key, *value, details),
                          Object);
     // TODO(mstarzinger): Temporary wrapper until handlified.
     static Handle<NameDictionary> NameDictionaryAdd(Handle<NameDictionary> dict,
                                                     Handle<Name> name,
                                                     Handle<Object> value,
                                                     PropertyDetails details) {
       CALL_HEAP_FUNCTION(dict->GetIsolate(),
                          dict->Add(*name, *value, details),
                          NameDictionary);
+    }
     MaybeObject* JSObject::SetNormalizedProperty(Name* name,
                                                  Object* value,
                                                  PropertyDetails details) {
       ASSERT(!HasFastProperties());
       int entry = property_dictionary()->FindEntry(name);
     void JSObject::SetNormalizedProperty(Handle<JSObject> object,
                                          Handle<Name> name,
                                          Handle<Object> value,
                                          PropertyDetails details) {
       ASSERT(!object->HasFastProperties());
       Handle<NameDictionary> property_dictionary(object->property_dictionary());
       if (!name->IsUniqueName()) {
         name = object->GetIsolate()->factory()->InternalizedStringFromString(
             Handle<String>::cast(name));
+      }
       int entry = property_dictionary->FindEntry(*name);
       if (entry == NameDictionary::kNotFound) {
         Object* store_value = value;
         if (IsGlobalObject()) {
           Heap* heap = name->GetHeap();
           MaybeObject* maybe_store_value = heap->AllocatePropertyCell(value);
           if (!maybe_store_value->ToObject(&store_value)) return maybe_store_value;
+        }
         Object* dict;
         { MaybeObject* maybe_dict =
               property_dictionary()->Add(name, store_value, details);
           if (!maybe_dict->ToObject(&dict)) return maybe_dict;
         Handle<Object> store_value = value;
         if (object->IsGlobalObject()) {
           store_value = object->GetIsolate()->factory()->NewPropertyCell(value);
+        }
         set_properties(NameDictionary::cast(dict));
         return value;
         property_dictionary =
             NameDictionaryAdd(property_dictionary, name, store_value, details);
         object->set_properties(*property_dictionary);
         return;
+      }
       PropertyDetails original_details = property_dictionary()->DetailsAt(entry);
       PropertyDetails original_details = property_dictionary->DetailsAt(entry);
       int enumeration_index;
       // Preserve the enumeration index unless the property was deleted.
       if (original_details.IsDeleted()) {
         enumeration_index = property_dictionary()->NextEnumerationIndex();
         property_dictionary()->SetNextEnumerationIndex(enumeration_index + 1);
         enumeration_index = property_dictionary->NextEnumerationIndex();
         property_dictionary->SetNextEnumerationIndex(enumeration_index + 1);
       } else {
         enumeration_index = original_details.dictionary_index();
         ASSERT(enumeration_index > 0);
-...
       details = PropertyDetails(
           details.attributes(), details.type(), enumeration_index);
       if (IsGlobalObject()) {
         PropertyCell* cell =
             PropertyCell::cast(property_dictionary()->ValueAt(entry));
         MaybeObject* maybe_type = cell->SetValueInferType(value);
         if (maybe_type->IsFailure()) return maybe_type;
       if (object->IsGlobalObject()) {
         Handle<PropertyCell> cell(
             PropertyCell::cast(property_dictionary->ValueAt(entry)));
         PropertyCell::SetValueInferType(cell, value);
         // Please note we have to update the property details.
         property_dictionary()->DetailsAtPut(entry, details);
         property_dictionary->DetailsAtPut(entry, details);
       } else {
         property_dictionary()->SetEntry(entry, name, value, details);
         property_dictionary->SetEntry(entry, *name, *value, details);
+      }
       return value;
+    }
-...
+    }
     static void CellSetValueInferType(Handle<PropertyCell> cell,
                                       Handle<Object> value) {
       CALL_HEAP_FUNCTION_VOID(cell->GetIsolate(), cell->SetValueInferType(*value));
+    }
     Handle<Object> JSObject::DeleteNormalizedProperty(Handle<JSObject> object,
                                                       Handle<Name> name,
                                                       DeleteMode mode) {
-...
             object->set_map(*new_map);
+          }
           Handle<PropertyCell> cell(PropertyCell::cast(dictionary->ValueAt(entry)));
           CellSetValueInferType(cell, isolate->factory()->the_hole_value());
           Handle<Object> value = isolate->factory()->the_hole_value();
           PropertyCell::SetValueInferType(cell, value);
           dictionary->DetailsAtPut(entry, details.AsDeleted());
         } else {
           Handle<Object> deleted(dictionary->DeleteProperty(entry, mode), isolate);
-...
+    }
     // TODO(yangguo): handlify this and get rid of.
     MaybeObject* Object::GetProperty(Object* receiver,
                                      LookupResult* result,
                                      Name* name,
                                      PropertyAttributes* attributes) {
       // Make sure that the top context does not change when doing
       // callbacks or interceptor calls.
       AssertNoContextChangeWithHandleScope ncc;
       Isolate* isolate = name->GetIsolate();
       Heap* heap = isolate->heap();
     #ifdef DEBUG
       // TODO(mstarzinger): Only because of the AssertNoContextChange, drop as soon
       // as this method has been fully handlified.
       HandleScope scope(isolate);
     #endif
       // Make sure that the top context does not change when doing
       // callbacks or interceptor calls.
       AssertNoContextChange ncc(isolate);
       // Traverse the prototype chain from the current object (this) to
       // the holder and check for access rights. This avoids traversing the
       // objects more than once in case of interceptors, because the
-...
             // property from the current object, we still check that we have
             // access to it.
             JSObject* checked = JSObject::cast(current);
             if (!heap->isolate()->MayNamedAccess(checked, name, v8::ACCESS_GET)) {
               return checked->GetPropertyWithFailedAccessCheck(receiver,
                                                                result,
                                                                name,
                                                                attributes);
             if (!isolate->MayNamedAccess(checked, name, v8::ACCESS_GET)) {
               HandleScope scope(isolate);
               Handle<Object> value = JSObject::GetPropertyWithFailedAccessCheck(
                   handle(checked, isolate),
                   handle(receiver, isolate),
                   result,
                   handle(name, isolate),
                   attributes);
               RETURN_IF_EMPTY_HANDLE(isolate, value);
               return *value;
+            }
+          }
           // Stop traversing the chain once we reach the last object in the
-...
+        }
         case CONSTANT:
           return result->GetConstant();
         case CALLBACKS:
           return result->holder()->GetPropertyWithCallback(
               receiver, result->GetCallbackObject(), name);
         case CALLBACKS: {
           HandleScope scope(isolate);
           Handle<Object> value = JSObject::GetPropertyWithCallback(
               handle(result->holder(), isolate),
               handle(receiver, isolate),
               handle(result->GetCallbackObject(), isolate),
               handle(name, isolate));
           RETURN_IF_EMPTY_HANDLE(isolate, value);
           return *value;
+        }
         case HANDLER:
           return result->proxy()->GetPropertyWithHandler(receiver, name);
         case INTERCEPTOR:
           return result->holder()->GetPropertyWithInterceptor(
               receiver, name, attributes);
         case INTERCEPTOR: {
           HandleScope scope(isolate);
           Handle<Object> value = JSObject::GetPropertyWithInterceptor(
               handle(result->holder(), isolate),
               handle(receiver, isolate),
               handle(name, isolate),
               attributes);
           RETURN_IF_EMPTY_HANDLE(isolate, value);
           return *value;
+        }
         case TRANSITION:
         case NONEXISTENT:
           UNREACHABLE();
-...
       if (IsNumber() && other->IsNumber()) {
         double this_value = Number();
         double other_value = other->Number();
         return (this_value == other_value) ||
             (std::isnan(this_value) && std::isnan(other_value));
         bool equal = this_value == other_value;
         // SameValue(NaN, NaN) is true.
         if (!equal) return std::isnan(this_value) && std::isnan(other_value);
         // SameValue(0.0, -0.0) is false.
         return (this_value != 0) || ((1 / this_value) == (1 / other_value));
+      }
       if (IsString() && other->IsString()) {
         return String::cast(this)->Equals(String::cast(other));
-...
       // Externalizing twice leaks the external resource, so it's
       // prohibited by the API.
       ASSERT(!this->IsExternalString());
     #ifdef DEBUG
     #ifdef ENABLE_SLOW_ASSERTS
       if (FLAG_enable_slow_asserts) {
         // Assert that the resource and the string are equivalent.
         ASSERT(static_cast<size_t>(this->length()) == resource->length());
-...
     bool String::MakeExternal(v8::String::ExternalAsciiStringResource* resource) {
     #ifdef DEBUG
     #ifdef ENABLE_SLOW_ASSERTS
       if (FLAG_enable_slow_asserts) {
         // Assert that the resource and the string are equivalent.
         ASSERT(static_cast<size_t>(this->length()) == resource->length());
-...
         case FIXED_ARRAY_TYPE:
           FixedArray::BodyDescriptor::IterateBody(this, object_size, v);
           break;
         case CONSTANT_POOL_ARRAY_TYPE:
           reinterpret_cast<ConstantPoolArray*>(this)->ConstantPoolIterateBody(v);
           break;
         case FIXED_DOUBLE_ARRAY_TYPE:
           break;
         case JS_OBJECT_TYPE:
-...
+    }
     MaybeObject* JSObject::AddFastPropertyUsingMap(Map* new_map,
                                                    Name* name,
                                                    Object* value,
                                                    int field_index,
                                                    Representation representation) {
     // TODO(mstarzinger): Temporary wrapper until handlified.
     static Handle<Object> NewStorageFor(Isolate* isolate,
                                         Handle<Object> object,
                                         Representation representation) {
       Heap* heap = isolate->heap();
       CALL_HEAP_FUNCTION(isolate,
                          object->AllocateNewStorageFor(heap, representation),
                          Object);
+    }
     void JSObject::AddFastPropertyUsingMap(Handle<JSObject> object,
                                            Handle<Map> new_map,
                                            Handle<Name> name,
                                            Handle<Object> value,
                                            int field_index,
                                            Representation representation) {
       Isolate* isolate = object->GetIsolate();
       // This method is used to transition to a field. If we are transitioning to a
       // double field, allocate new storage.
       Object* storage;
       MaybeObject* maybe_storage =
           value->AllocateNewStorageFor(GetHeap(), representation);
       if (!maybe_storage->To(&storage)) return maybe_storage;
       Handle<Object> storage = NewStorageFor(isolate, value, representation);
       if (map()->unused_property_fields() == 0) {
       if (object->map()->unused_property_fields() == 0) {
         int new_unused = new_map->unused_property_fields();
         FixedArray* values;
         MaybeObject* maybe_values =
             properties()->CopySize(properties()->length() + new_unused + 1);
         if (!maybe_values->To(&values)) return maybe_values;
         Handle<FixedArray> properties(object->properties());
         Handle<FixedArray> values = isolate->factory()->CopySizeFixedArray(
             properties, properties->length() + new_unused + 1);
         object->set_properties(*values);
+      }
       object->set_map(*new_map);
       object->FastPropertyAtPut(field_index, *storage);
+    }
         set_properties(values);
     static MaybeObject* CopyAddFieldDescriptor(Map* map,
                                                Name* name,
                                                int index,
                                                PropertyAttributes attributes,
                                                Representation representation,
                                                TransitionFlag flag) {
       Map* new_map;
       FieldDescriptor new_field_desc(name, index, attributes, representation);
       MaybeObject* maybe_map = map->CopyAddDescriptor(&new_field_desc, flag);
       if (!maybe_map->To(&new_map)) return maybe_map;
       int unused_property_fields = map->unused_property_fields() - 1;
       if (unused_property_fields < 0) {
         unused_property_fields += JSObject::kFieldsAdded;
+      }
       new_map->set_unused_property_fields(unused_property_fields);
       return new_map;
+    }
       set_map(new_map);
       FastPropertyAtPut(field_index, storage);
       return value;
     static Handle<Map> CopyAddFieldDescriptor(Handle<Map> map,
                                               Handle<Name> name,
                                               int index,
                                               PropertyAttributes attributes,
                                               Representation representation,
                                               TransitionFlag flag) {
       CALL_HEAP_FUNCTION(map->GetIsolate(),
                          CopyAddFieldDescriptor(
                              *map, *name, index, attributes, representation, flag),
                          Map);
+    }
     MaybeObject* JSObject::AddFastProperty(Name* name,
                                            Object* value,
                                            PropertyAttributes attributes,
                                            StoreFromKeyed store_mode,
                                            ValueType value_type,
                                            TransitionFlag flag) {
       ASSERT(!IsJSGlobalProxy());
     void JSObject::AddFastProperty(Handle<JSObject> object,
                                    Handle<Name> name,
                                    Handle<Object> value,
                                    PropertyAttributes attributes,
                                    StoreFromKeyed store_mode,
                                    ValueType value_type,
                                    TransitionFlag flag) {
       ASSERT(!object->IsJSGlobalProxy());
       ASSERT(DescriptorArray::kNotFound ==
              map()->instance_descriptors()->Search(
                  name, map()->NumberOfOwnDescriptors()));
              object->map()->instance_descriptors()->Search(
                  *name, object->map()->NumberOfOwnDescriptors()));
       // Normalize the object if the name is an actual name (not the
       // hidden strings) and is not a real identifier.
       // Normalize the object if it will have too many fast properties.
       Isolate* isolate = GetHeap()->isolate();
       if (!name->IsCacheable(isolate) || TooManyFastProperties(store_mode)) {
         MaybeObject* maybe_failure =
             NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
         if (maybe_failure->IsFailure()) return maybe_failure;
         return AddSlowProperty(name, value, attributes);
       Isolate* isolate = object->GetIsolate();
       if (!name->IsCacheable(isolate) ||
           object->TooManyFastProperties(store_mode)) {
         NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0);
         AddSlowProperty(object, name, value, attributes);
         return;
+      }
       // Compute the new index for new field.
       int index = map()->NextFreePropertyIndex();
       int index = object->map()->NextFreePropertyIndex();
       // Allocate new instance descriptors with (name, index) added
       if (IsJSContextExtensionObject()) value_type = FORCE_TAGGED;
       if (object->IsJSContextExtensionObject()) value_type = FORCE_TAGGED;
       Representation representation = value->OptimalRepresentation(value_type);
       Handle<Map> new_map = CopyAddFieldDescriptor(
           handle(object->map()), name, index, attributes, representation, flag);
       FieldDescriptor new_field(name, index, attributes, representation);
       Map* new_map;
       MaybeObject* maybe_new_map = map()->CopyAddDescriptor(&new_field, flag);
       if (!maybe_new_map->To(&new_map)) return maybe_new_map;
       AddFastPropertyUsingMap(object, new_map, name, value, index, representation);
+    }
       int unused_property_fields = map()->unused_property_fields() - 1;
       if (unused_property_fields < 0) {
         unused_property_fields += kFieldsAdded;
+      }
       new_map->set_unused_property_fields(unused_property_fields);
       return AddFastPropertyUsingMap(new_map, name, value, index, representation);
     static MaybeObject* CopyAddConstantDescriptor(Map* map,
                                                   Name* name,
                                                   Object* value,
                                                   PropertyAttributes attributes,
                                                   TransitionFlag flag) {
       ConstantDescriptor new_constant_desc(name, value, attributes);
       return map->CopyAddDescriptor(&new_constant_desc, flag);
+    }
     MaybeObject* JSObject::AddConstantProperty(
         Name* name,
         Object* constant,
         PropertyAttributes attributes,
         TransitionFlag initial_flag) {
       // Allocate new instance descriptors with (name, constant) added
       ConstantDescriptor d(name, constant, attributes);
     static Handle<Map> CopyAddConstantDescriptor(Handle<Map> map,
                                                  Handle<Name> name,
                                                  Handle<Object> value,
                                                  PropertyAttributes attributes,
                                                  TransitionFlag flag) {
       CALL_HEAP_FUNCTION(map->GetIsolate(),
                          CopyAddConstantDescriptor(
                              *map, *name, *value, attributes, flag),
                          Map);
+    }
     void JSObject::AddConstantProperty(Handle<JSObject> object,
                                        Handle<Name> name,
                                        Handle<Object> constant,
                                        PropertyAttributes attributes,
                                        TransitionFlag initial_flag) {
       TransitionFlag flag =
           // Do not add transitions to global objects.
           (IsGlobalObject() ||
           (object->IsGlobalObject() ||
           // Don't add transitions to special properties with non-trivial
           // attributes.
            attributes != NONE)
           ? OMIT_TRANSITION
           : initial_flag;
       Map* new_map;
       MaybeObject* maybe_new_map = map()->CopyAddDescriptor(&d, flag);
       if (!maybe_new_map->To(&new_map)) return maybe_new_map;
       // Allocate new instance descriptors with (name, constant) added.
       Handle<Map> new_map = CopyAddConstantDescriptor(
           handle(object->map()), name, constant, attributes, flag);
       set_map(new_map);
       return constant;
       object->set_map(*new_map);
+    }
     // Add property in slow mode
     MaybeObject* JSObject::AddSlowProperty(Name* name,
                                            Object* value,
                                            PropertyAttributes attributes) {
       ASSERT(!HasFastProperties());
       NameDictionary* dict = property_dictionary();
       Object* store_value = value;
       if (IsGlobalObject()) {
     void JSObject::AddSlowProperty(Handle<JSObject> object,
                                    Handle<Name> name,
                                    Handle<Object> value,
                                    PropertyAttributes attributes) {
       ASSERT(!object->HasFastProperties());
       Isolate* isolate = object->GetIsolate();
       Handle<NameDictionary> dict(object->property_dictionary());
       if (object->IsGlobalObject()) {
         // In case name is an orphaned property reuse the cell.
         int entry = dict->FindEntry(name);
         int entry = dict->FindEntry(*name);
         if (entry != NameDictionary::kNotFound) {
           store_value = dict->ValueAt(entry);
           MaybeObject* maybe_type =
               PropertyCell::cast(store_value)->SetValueInferType(value);
           if (maybe_type->IsFailure()) return maybe_type;
           Handle<PropertyCell> cell(PropertyCell::cast(dict->ValueAt(entry)));
           PropertyCell::SetValueInferType(cell, value);
           // Assign an enumeration index to the property and update
           // SetNextEnumerationIndex.
           int index = dict->NextEnumerationIndex();
           PropertyDetails details = PropertyDetails(attributes, NORMAL, index);
           dict->SetNextEnumerationIndex(index + 1);
           dict->SetEntry(entry, name, store_value, details);
           return value;
+        }
         Heap* heap = GetHeap();
         { MaybeObject* maybe_store_value =
               heap->AllocatePropertyCell(value);
           if (!maybe_store_value->ToObject(&store_value)) return maybe_store_value;
           dict->SetEntry(entry, *name, *cell, details);
           return;
+        }
         MaybeObject* maybe_type =
             PropertyCell::cast(store_value)->SetValueInferType(value);
         if (maybe_type->IsFailure()) return maybe_type;
         Handle<PropertyCell> cell = isolate->factory()->NewPropertyCell(value);
         PropertyCell::SetValueInferType(cell, value);
         value = cell;
+      }
       PropertyDetails details = PropertyDetails(attributes, NORMAL, 0);
       Object* result;
       { MaybeObject* maybe_result = dict->Add(name, store_value, details);
         if (!maybe_result->ToObject(&result)) return maybe_result;
+      }
       if (dict != result) set_properties(NameDictionary::cast(result));
       return value;
       Handle<NameDictionary> result = NameDictionaryAdd(dict, name, value, details);
       if (*dict != *result) object->set_properties(*result);
+    }
     MaybeObject* JSObject::AddProperty(Name* name,
                                        Object* value,
                                        PropertyAttributes attributes,
                                        StrictModeFlag strict_mode,
                                        JSReceiver::StoreFromKeyed store_mode,
                                        ExtensibilityCheck extensibility_check,
                                        ValueType value_type,
                                        StoreMode mode,
                                        TransitionFlag transition_flag) {
       ASSERT(!IsJSGlobalProxy());
       Map* map_of_this = map();
       Heap* heap = GetHeap();
       Isolate* isolate = heap->isolate();
       MaybeObject* result;
     Handle<Object> JSObject::AddProperty(Handle<JSObject> object,
                                          Handle<Name> name,
                                          Handle<Object> value,
                                          PropertyAttributes attributes,
                                          StrictModeFlag strict_mode,
                                          JSReceiver::StoreFromKeyed store_mode,
                                          ExtensibilityCheck extensibility_check,
                                          ValueType value_type,
                                          StoreMode mode,
                                          TransitionFlag transition_flag) {
       ASSERT(!object->IsJSGlobalProxy());
       Isolate* isolate = object->GetIsolate();
       if (!name->IsUniqueName()) {
         name = isolate->factory()->InternalizedStringFromString(
             Handle<String>::cast(name));
+      }
       if (extensibility_check == PERFORM_EXTENSIBILITY_CHECK &&
           !map_of_this->is_extensible()) {
           !object->map()->is_extensible()) {
         if (strict_mode == kNonStrictMode) {
           return value;
         } else {
           Handle<Object> args[1] = {Handle<Name>(name)};
           return isolate->Throw(
               *isolate->factory()->NewTypeError("object_not_extensible",
                                                 HandleVector(args, 1)));
           Handle<Object> args[1] = { name };
           Handle<Object> error = isolate->factory()->NewTypeError(
               "object_not_extensible", HandleVector(args, ARRAY_SIZE(args)));
           isolate->Throw(*error);
           return Handle<Object>();
+        }
+      }
       if (HasFastProperties()) {
       if (object->HasFastProperties()) {
         // Ensure the descriptor array does not get too big.
         if (map_of_this->NumberOfOwnDescriptors() <
         if (object->map()->NumberOfOwnDescriptors() <
             DescriptorArray::kMaxNumberOfDescriptors) {
           // TODO(verwaest): Support other constants.
           // if (mode == ALLOW_AS_CONSTANT &&
           //     !value->IsTheHole() &&
           //     !value->IsConsString()) {
           if (value->IsJSFunction()) {
             result = AddConstantProperty(name, value, attributes, transition_flag);
             AddConstantProperty(object, name, value, attributes, transition_flag);
           } else {
             result = AddFastProperty(
                 name, value, attributes, store_mode, value_type, transition_flag);
             AddFastProperty(object, name, value, attributes, store_mode,
                             value_type, transition_flag);
+          }
         } else {
           // Normalize the object to prevent very large instance descriptors.
           // This eliminates unwanted N^2 allocation and lookup behavior.
           Object* obj;
           MaybeObject* maybe = NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
           if (!maybe->To(&obj)) return maybe;
           result = AddSlowProperty(name, value, attributes);
           NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0);
           AddSlowProperty(object, name, value, attributes);
+        }
       } else {
         result = AddSlowProperty(name, value, attributes);
         AddSlowProperty(object, name, value, attributes);
+      }
       Handle<Object> hresult;
       if (!result->ToHandle(&hresult, isolate)) return result;
       if (FLAG_harmony_observation && map()->is_observed()) {
         EnqueueChangeRecord(handle(this, isolate),
                             "new",
                             handle(name, isolate),
                             handle(heap->the_hole_value(), isolate));
       if (FLAG_harmony_observation &&
           object->map()->is_observed() &&
           *name != isolate->heap()->hidden_string()) {
         Handle<Object> old_value = isolate->factory()->the_hole_value();
         EnqueueChangeRecord(object, "new", name, old_value);
+      }
       return *hresult;
       return value;
+    }
-...
+    }
     MaybeObject* JSObject::SetPropertyPostInterceptor(
         Name* name,
         Object* value,
     Handle<Object> JSObject::SetPropertyPostInterceptor(
         Handle<JSObject> object,
         Handle<Name> name,
         Handle<Object> value,
         PropertyAttributes attributes,
         StrictModeFlag strict_mode,
         StoreMode mode) {
         StrictModeFlag strict_mode) {
       // Check local property, ignore interceptor.
       LookupResult result(GetIsolate());
       LocalLookupRealNamedProperty(name, &result);
       if (!result.IsFound()) map()->LookupTransition(this, name, &result);
       LookupResult result(object->GetIsolate());
       object->LocalLookupRealNamedProperty(*name, &result);
       if (!result.IsFound()) {
         object->map()->LookupTransition(*object, *name, &result);
+      }
       if (result.IsFound()) {
         // An existing property or a map transition was found. Use set property to
         // handle all these cases.
         return SetProperty(&result, name, value, attributes, strict_mode);
         return SetPropertyForResult(object, &result, name, value, attributes,
                                     strict_mode, MAY_BE_STORE_FROM_KEYED);
+      }
       bool done = false;
       MaybeObject* result_object =
           SetPropertyViaPrototypes(name, value, attributes, strict_mode, &done);
       Handle<Object> result_object = SetPropertyViaPrototypes(
           object, name, value, attributes, strict_mode, &done);
       if (done) return result_object;
       // Add a new real property.
       return AddProperty(name, value, attributes, strict_mode,
                          MAY_BE_STORE_FROM_KEYED, PERFORM_EXTENSIBILITY_CHECK,
                          OPTIMAL_REPRESENTATION, mode);
       return AddProperty(object, name, value, attributes, strict_mode);
+    }
     MaybeObject* JSObject::ReplaceSlowProperty(Name* name,
                                                Object* value,
                                                PropertyAttributes attributes) {
       NameDictionary* dictionary = property_dictionary();
       int old_index = dictionary->FindEntry(name);
     static void ReplaceSlowProperty(Handle<JSObject> object,
                                     Handle<Name> name,
                                     Handle<Object> value,
                                     PropertyAttributes attributes) {
       NameDictionary* dictionary = object->property_dictionary();
       int old_index = dictionary->FindEntry(*name);
       int new_enumeration_index = 0;  // 0 means "Use the next available index."
       if (old_index != -1) {
         // All calls to ReplaceSlowProperty have had all transitions removed.
-...
+      }
       PropertyDetails new_details(attributes, NORMAL, new_enumeration_index);
       return SetNormalizedProperty(name, value, new_details);
       JSObject::SetNormalizedProperty(object, name, value, new_details);
+    }
-...
           MemoryChunk::IncrementLiveBytesFromMutator(elms->address(), -size_delta);
+        }
+      }
       // The array may not be moved during GC,
       // and size has to be adjusted nevertheless.
       HeapProfiler* profiler = heap->isolate()->heap_profiler();
       if (profiler->is_tracking_allocations()) {
         profiler->UpdateObjectSizeEvent(elms->address(), elms->Size());
+      }
+    }
-...
     //     to temporarily store the inobject properties.
     //   * If there are properties left in the backing store, install the backing
     //     store.
     MaybeObject* JSObject::MigrateToMap(Map* new_map) {
       Heap* heap = GetHeap();
       Map* old_map = map();
     void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map) {
       Isolate* isolate = object->GetIsolate();
       Handle<Map> old_map(object->map());
       int number_of_fields = new_map->NumberOfFields();
       int inobject = new_map->inobject_properties();
       int unused = new_map->unused_property_fields();
       // Nothing to do if no functions were converted to fields.
       // Nothing to do if no functions were converted to fields and no smis were
       // converted to doubles.
       if (!old_map->InstancesNeedRewriting(
               new_map, number_of_fields, inobject, unused)) {
         set_map(new_map);
         return this;
               *new_map, number_of_fields, inobject, unused)) {
         object->set_map(*new_map);
         return;
+      }
       int total_size = number_of_fields + unused;
       int external = total_size - inobject;
       FixedArray* array;
       MaybeObject* maybe_array = heap->AllocateFixedArray(total_size);
       if (!maybe_array->To(&array)) return maybe_array;
       Handle<FixedArray> array = isolate->factory()->NewFixedArray(total_size);
       DescriptorArray* old_descriptors = old_map->instance_descriptors();
       DescriptorArray* new_descriptors = new_map->instance_descriptors();
       Handle<DescriptorArray> old_descriptors(old_map->instance_descriptors());
       Handle<DescriptorArray> new_descriptors(new_map->instance_descriptors());
       int descriptors = new_map->NumberOfOwnDescriptors();
       for (int i = 0; i < descriptors; i++) {
-...
+        }
         ASSERT(old_details.type() == CONSTANT ||
                old_details.type() == FIELD);
         Object* value = old_details.type() == CONSTANT
         Object* raw_value = old_details.type() == CONSTANT
             ? old_descriptors->GetValue(i)
             : RawFastPropertyAt(old_descriptors->GetFieldIndex(i));
             : object->RawFastPropertyAt(old_descriptors->GetFieldIndex(i));
         Handle<Object> value(raw_value, isolate);
         if (FLAG_track_double_fields &&
             !old_details.representation().IsDouble() &&
             details.representation().IsDouble()) {
           if (old_details.representation().IsNone()) value = Smi::FromInt(0);
           // Objects must be allocated in the old object space, since the
           // overall number of HeapNumbers needed for the conversion might
           // exceed the capacity of new space, and we would fail repeatedly
           // trying to migrate the instance.
           MaybeObject* maybe_storage =
               value->AllocateNewStorageFor(heap, details.representation(), TENURED);
           if (!maybe_storage->To(&value)) return maybe_storage;
           if (old_details.representation().IsNone()) {
             value = handle(Smi::FromInt(0), isolate);
+          }
           value = NewStorageFor(isolate, value, details.representation());
+        }
         ASSERT(!(FLAG_track_double_fields &&
                  details.representation().IsDouble() &&
                  value->IsSmi()));
         int target_index = new_descriptors->GetFieldIndex(i) - inobject;
         if (target_index < 0) target_index += total_size;
         array->set(target_index, value);
         array->set(target_index, *value);
+      }
       // From here on we cannot fail anymore.
       // From here on we cannot fail and we shouldn't GC anymore.
       DisallowHeapAllocation no_allocation;
       // Copy (real) inobject properties. If necessary, stop at number_of_fields to
       // avoid overwriting |one_pointer_filler_map|.
       int limit = Min(inobject, number_of_fields);
       for (int i = 0; i < limit; i++) {
         FastPropertyAtPut(i, array->get(external + i));
         object->FastPropertyAtPut(i, array->get(external + i));
+      }
       // Create filler object past the new instance size.
       int new_instance_size = new_map->instance_size();
       int instance_size_delta = old_map->instance_size() - new_instance_size;
       ASSERT(instance_size_delta >= 0);
       Address address = this->address() + new_instance_size;
       heap->CreateFillerObjectAt(address, instance_size_delta);
       Address address = object->address() + new_instance_size;
       isolate->heap()->CreateFillerObjectAt(address, instance_size_delta);
       // If there are properties in the new backing store, trim it to the correct
       // size and install the backing store into the object.
       if (external > 0) {
         RightTrimFixedArray<FROM_MUTATOR>(heap, array, inobject);
         set_properties(array);
         RightTrimFixedArray<FROM_MUTATOR>(isolate->heap(), *array, inobject);
         object->set_properties(*array);
+      }
       set_map(new_map);
       return this;
       object->set_map(*new_map);
+    }
     MaybeObject* JSObject::GeneralizeFieldRepresentation(
         int modify_index,
         Representation new_representation,
         StoreMode store_mode) {
       Map* new_map;
       MaybeObject* maybe_new_map = map()->GeneralizeRepresentation(
           modify_index, new_representation, store_mode);
       if (!maybe_new_map->To(&new_map)) return maybe_new_map;
       if (map() == new_map) return this;
     Handle<TransitionArray> Map::AddTransition(Handle<Map> map,
                                                Handle<Name> key,
                                                Handle<Map> target,
                                                SimpleTransitionFlag flag) {
       CALL_HEAP_FUNCTION(map->GetIsolate(),
                          map->AddTransition(*key, *target, flag),
                          TransitionArray);
+    }
       return MigrateToMap(new_map);
     void JSObject::GeneralizeFieldRepresentation(Handle<JSObject> object,
                                                  int modify_index,
                                                  Representation new_representation,
                                                  StoreMode store_mode) {
       Handle<Map> new_map = Map::GeneralizeRepresentation(
           handle(object->map()), modify_index, new_representation, store_mode);
       if (object->map() == *new_map) return;
       return MigrateToMap(object, new_map);
+    }
-...
+    }
     MaybeObject* Map::CopyGeneralizeAllRepresentations(
         int modify_index,
         StoreMode store_mode,
         PropertyAttributes attributes,
         const char* reason) {
       Map* new_map;
       MaybeObject* maybe_map = this->Copy();
       if (!maybe_map->To(&new_map)) return maybe_map;
     Handle<Map> Map::CopyGeneralizeAllRepresentations(Handle<Map> map,
                                                       int modify_index,
                                                       StoreMode store_mode,
                                                       PropertyAttributes attributes,
                                                       const char* reason) {
       Handle<Map> new_map = Copy(map);
       DescriptorArray* descriptors = new_map->instance_descriptors();
       descriptors->InitializeRepresentations(Representation::Tagged());
-...
+      }
       if (FLAG_trace_generalization) {
         PrintGeneralization(stdout, reason, modify_index,
         map->PrintGeneralization(stdout, reason, modify_index,
                             new_map->NumberOfOwnDescriptors(),
                             new_map->NumberOfOwnDescriptors(),
                             details.type() == CONSTANT && store_mode == FORCE_FIELD,
-...
     // - If |updated| == |split_map|, |updated| is in the expected state. Return it.
     // - Otherwise, invalidate the outdated transition target from |updated|, and
     //   replace its transition tree with a new branch for the updated descriptors.
     MaybeObject* Map::GeneralizeRepresentation(int modify_index,
                                                Representation new_representation,
                                                StoreMode store_mode) {
       Map* old_map = this;
       DescriptorArray* old_descriptors = old_map->instance_descriptors();
     Handle<Map> Map::GeneralizeRepresentation(Handle<Map> old_map,
                                               int modify_index,
                                               Representation new_representation,
                                               StoreMode store_mode) {
       Handle<DescriptorArray> old_descriptors(old_map->instance_descriptors());
       PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
       Representation old_representation = old_details.representation();
-...
+      }
       int descriptors = old_map->NumberOfOwnDescriptors();
       Map* root_map = old_map->FindRootMap();
       Handle<Map> root_map(old_map->FindRootMap());
       // Check the state of the root map.
       if (!old_map->EquivalentToForTransition(root_map)) {
         return CopyGeneralizeAllRepresentations(
             modify_index, store_mode, old_details.attributes(), "not equivalent");
       if (!old_map->EquivalentToForTransition(*root_map)) {
         return CopyGeneralizeAllRepresentations(old_map, modify_index, store_mode,
             old_details.attributes(), "not equivalent");
+      }
       int verbatim = root_map->NumberOfOwnDescriptors();
       if (store_mode != ALLOW_AS_CONSTANT && modify_index < verbatim) {
         return CopyGeneralizeAllRepresentations(
             modify_index, store_mode,
         return CopyGeneralizeAllRepresentations(old_map, modify_index, store_mode,
             old_details.attributes(), "root modification");
+      }
       Map* updated = root_map->FindUpdatedMap(
           verbatim, descriptors, old_descriptors);
       if (updated == NULL) {
         return CopyGeneralizeAllRepresentations(
             modify_index, store_mode, old_details.attributes(), "incompatible");
       Map* raw_updated = root_map->FindUpdatedMap(
           verbatim, descriptors, *old_descriptors);
       if (raw_updated == NULL) {
         return CopyGeneralizeAllRepresentations(old_map, modify_index, store_mode,
             old_details.attributes(), "incompatible");
+      }
       DescriptorArray* updated_descriptors = updated->instance_descriptors();
       Handle<Map> updated(raw_updated);
       Handle<DescriptorArray> updated_descriptors(updated->instance_descriptors());
       int valid = updated->NumberOfOwnDescriptors();
       // Directly change the map if the target map is more general. Ensure that the
       // target type of the modify_index is a FIELD, unless we are migrating.
       if (updated_descriptors->IsMoreGeneralThan(
               verbatim, valid, descriptors, old_descriptors) &&
               verbatim, valid, descriptors, *old_descriptors) &&
           (store_mode == ALLOW_AS_CONSTANT ||
            updated_descriptors->GetDetails(modify_index).type() == FIELD)) {
         Representation updated_representation =
-...
         if (new_representation.fits_into(updated_representation)) return updated;
+      }
       DescriptorArray* new_descriptors;
       MaybeObject* maybe_descriptors = updated_descriptors->Merge(
           verbatim, valid, descriptors, modify_index, store_mode, old_descriptors);
       if (!maybe_descriptors->To(&new_descriptors)) return maybe_descriptors;
       Handle<DescriptorArray> new_descriptors = DescriptorArray::Merge(
           updated_descriptors, verbatim, valid, descriptors, modify_index,
           store_mode, old_descriptors);
       ASSERT(store_mode == ALLOW_AS_CONSTANT ||
              new_descriptors->GetDetails(modify_index).type() == FIELD);
-...
         new_descriptors->SetRepresentation(modify_index, updated_representation);
+      }
       Map* split_map = root_map->FindLastMatchMap(
           verbatim, descriptors, new_descriptors);
       Handle<Map> split_map(root_map->FindLastMatchMap(
           verbatim, descriptors, *new_descriptors));
       int split_descriptors = split_map->NumberOfOwnDescriptors();
       // This is shadowed by |updated_descriptors| being more general than
-...
       int descriptor = split_descriptors;
       split_map->DeprecateTarget(
           old_descriptors->GetKey(descriptor), new_descriptors);
           old_descriptors->GetKey(descriptor), *new_descriptors);
       if (FLAG_trace_generalization) {
         PrintGeneralization(
         old_map->PrintGeneralization(
             stdout, "", modify_index, descriptor, descriptors,
             old_descriptors->GetDetails(modify_index).type() == CONSTANT &&
                 store_mode == FORCE_FIELD,
             old_representation, updated_representation);
+      }
       Map* new_map = split_map;
       // Add missing transitions.
       Handle<Map> new_map = split_map;
       for (; descriptor < descriptors; descriptor++) {
         MaybeObject* maybe_map = new_map->CopyInstallDescriptors(
             descriptor, new_descriptors);
         if (!maybe_map->To(&new_map)) {
           // Create a handle for the last created map to ensure it stays alive
           // during GC. Its descriptor array is too large, but it will be
           // overwritten during retry anyway.
           Handle<Map>(new_map);
           return maybe_map;
+        }
         new_map = Map::CopyInstallDescriptors(new_map, descriptor, new_descriptors);
         new_map->set_migration_target(true);
+      }
-...
+    }
     Map* Map::CurrentMapForDeprecated() {
     // Generalize the representation of all FIELD descriptors.
     Handle<Map> Map::GeneralizeAllFieldRepresentations(
         Handle<Map> map,
         Representation new_representation) {
       Handle<DescriptorArray> descriptors(map->instance_descriptors());
       for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
         PropertyDetails details = descriptors->GetDetails(i);
         if (details.type() == FIELD) {
           map = GeneralizeRepresentation(map, i, new_representation, FORCE_FIELD);
+        }
+      }
       return map;
+    }
     Map* Map::CurrentMapForDeprecated() {
       DisallowHeapAllocation no_allocation;
       if (!is_deprecated()) return this;
-...
+    }
     MaybeObject* JSObject::SetPropertyWithInterceptor(
         Name* name,
         Object* value,
     Handle<Object> JSObject::SetPropertyWithInterceptor(
         Handle<JSObject> object,
         Handle<Name> name,
         Handle<Object> value,
         PropertyAttributes attributes,
         StrictModeFlag strict_mode) {
       // TODO(rossberg): Support symbols in the API.
       if (name->IsSymbol()) return value;
       Isolate* isolate = GetIsolate();
       HandleScope scope(isolate);
       Handle<JSObject> this_handle(this);
       Handle<String> name_handle(String::cast(name));
       Handle<Object> value_handle(value, isolate);
       Handle<InterceptorInfo> interceptor(GetNamedInterceptor());
       Isolate* isolate = object->GetIsolate();
       Handle<String> name_string = Handle<String>::cast(name);
       Handle<InterceptorInfo> interceptor(object->GetNamedInterceptor());
       if (!interceptor->setter()->IsUndefined()) {
         LOG(isolate, ApiNamedPropertyAccess("interceptor-named-set", this, name));
         PropertyCallbackArguments args(isolate, interceptor->data(), this, this);
         LOG(isolate,
             ApiNamedPropertyAccess("interceptor-named-set", *object, *name));
         PropertyCallbackArguments args(
             isolate, interceptor->data(), *object, *object);
         v8::NamedPropertySetterCallback setter =
             v8::ToCData<v8::NamedPropertySetterCallback>(interceptor->setter());
         Handle<Object> value_unhole(value->IsTheHole() ?
                                     isolate->heap()->undefined_value() :
                                     value,
                                     isolate);
         Handle<Object> value_unhole = value->IsTheHole()
             ? Handle<Object>(isolate->factory()->undefined_value()) : value;
         v8::Handle<v8::Value> result = args.Call(setter,
                                                  v8::Utils::ToLocal(name_handle),
                                                  v8::Utils::ToLocal(name_string),
                                                  v8::Utils::ToLocal(value_unhole));
         RETURN_IF_SCHEDULED_EXCEPTION(isolate);
         if (!result.IsEmpty()) return *value_handle;
         RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
         if (!result.IsEmpty()) return value;
+      }
       MaybeObject* raw_result =
           this_handle->SetPropertyPostInterceptor(*name_handle,
                                                   *value_handle,
                                                   attributes,
                                                   strict_mode);
       RETURN_IF_SCHEDULED_EXCEPTION(isolate);
       return raw_result;
       Handle<Object> result =
           SetPropertyPostInterceptor(object, name, value, attributes, strict_mode);
       RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
       return result;
+    }
     Handle<Object> JSReceiver::SetProperty(Handle<JSReceiver> object,
                                            Handle<Name> key,
                                            Handle<Name> name,
                                            Handle<Object> value,
                                            PropertyAttributes attributes,
                                            StrictModeFlag strict_mode) {
       CALL_HEAP_FUNCTION(object->GetIsolate(),
                          object->SetProperty(*key, *value, attributes, strict_mode),
                          Object);
+    }
     MaybeObject* JSReceiver::SetPropertyOrFail(
         Handle<JSReceiver> object,
         Handle<Name> key,
         Handle<Object> value,
         PropertyAttributes attributes,
         StrictModeFlag strict_mode,
         JSReceiver::StoreFromKeyed store_mode) {
       CALL_HEAP_FUNCTION_PASS_EXCEPTION(
           object->GetIsolate(),
           object->SetProperty(*key, *value, attributes, strict_mode, store_mode));
+    }
     MaybeObject* JSReceiver::SetProperty(Name* name,
                                          Object* value,
                                          PropertyAttributes attributes,
                                          StrictModeFlag strict_mode,
                                          JSReceiver::StoreFromKeyed store_mode) {
       LookupResult result(GetIsolate());
       LocalLookup(name, &result, true);
                                            StrictModeFlag strict_mode,
                                            StoreFromKeyed store_mode) {
       LookupResult result(object->GetIsolate());
       object->LocalLookup(*name, &result, true);
       if (!result.IsFound()) {
         map()->LookupTransition(JSObject::cast(this), name, &result);
         object->map()->LookupTransition(JSObject::cast(*object), *name, &result);
+      }
       return SetProperty(&result, name, value, attributes, strict_mode, store_mode);
       return SetProperty(object, &result, name, value, attributes, strict_mode,
                          store_mode);
+    }
     MaybeObject* JSObject::SetPropertyWithCallback(Object* structure,
                                                    Name* name,
                                                    Object* value,
                                                    JSObject* holder,
                                                    StrictModeFlag strict_mode) {
       Isolate* isolate = GetIsolate();
       HandleScope scope(isolate);
     Handle<Object> JSObject::SetPropertyWithCallback(Handle<JSObject> object,
                                                      Handle<Object> structure,
                                                      Handle<Name> name,
                                                      Handle<Object> value,
                                                      Handle<JSObject> holder,
                                                      StrictModeFlag strict_mode) {
       Isolate* isolate = object->GetIsolate();
       // We should never get here to initialize a const with the hole
       // value since a const declaration would conflict with the setter.
       ASSERT(!value->IsTheHole());
       Handle<Object> value_handle(value, isolate);
       // To accommodate both the old and the new api we switch on the
       // data structure used to store the callbacks.  Eventually foreign
-...
       if (structure->IsForeign()) {
         AccessorDescriptor* callback =
             reinterpret_cast<AccessorDescriptor*>(
                 Foreign::cast(structure)->foreign_address());
         MaybeObject* obj = (callback->setter)(
             isolate, this,  value, callback->data);
         RETURN_IF_SCHEDULED_EXCEPTION(isolate);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff