clang-format runtime/vm

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/bit_vector.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/safepoint.h"
 #include "vm/service_event.h"
 #include "vm/stack_frame.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_reload, false, "Trace isolate reloading");
-DEFINE_FLAG(bool, trace_reload_verbose, false,
+DEFINE_FLAG(bool,
+            trace_reload_verbose,
+            false,
             "trace isolate reloading verbose");
 DEFINE_FLAG(bool, identity_reload, false, "Enable checks for identity reload.");
 DEFINE_FLAG(int, reload_every, 0, "Reload every N stack overflow checks.");
 DEFINE_FLAG(bool, reload_every_optimized, true, "Only from optimized code.");
-DEFINE_FLAG(bool, reload_every_back_off, false,
+DEFINE_FLAG(bool,
+            reload_every_back_off,
+            false,
             "Double the --reload-every value after each reload.");
-DEFINE_FLAG(bool, reload_force_rollback, false,
+DEFINE_FLAG(bool,
+            reload_force_rollback,
+            false,
             "Force all reloads to fail and rollback.");
-DEFINE_FLAG(bool, check_reloaded, false,
+DEFINE_FLAG(bool,
+            check_reloaded,
+            false,
             "Assert that an isolate has reloaded at least once.")
 #ifndef PRODUCT
 
 #define I (isolate())
 #define Z (thread->zone())
 
 #define TIMELINE_SCOPE(name)                                                   \
-    TimelineDurationScope tds##name(Thread::Current(),                         \
-                                   Timeline::GetIsolateStream(),               \
-                                   #name)
+  TimelineDurationScope tds##name(Thread::Current(),                           \
+                                  Timeline::GetIsolateStream(), #name)
 
 
 InstanceMorpher::InstanceMorpher(Zone* zone, const Class& from, const Class& to)
     : from_(Class::Handle(zone, from.raw())),
       to_(Class::Handle(zone, to.raw())),
       mapping_(zone, 0) {
   ComputeMapping();
-  before_ = new(zone) ZoneGrowableArray<const Instance*>(zone, 0);
-  after_ = new(zone) ZoneGrowableArray<const Instance*>(zone, 0);
+  before_ = new (zone) ZoneGrowableArray<const Instance*>(zone, 0);
+  after_ = new (zone) ZoneGrowableArray<const Instance*>(zone, 0);
   ASSERT(from_.id() == to_.id());
   cid_ = from_.id();
 }
 
 
 void InstanceMorpher::AddObject(RawObject* object) const {
   ASSERT(object->GetClassId() == cid());
   const Instance& instance = Instance::Cast(Object::Handle(object));
   before_->Add(&instance);
 }
@@ skipping 35 matching lines @@
         mapping_.Add(to_field.Offset());
       }
     }
   }
 }
 
 
 RawInstance* InstanceMorpher::Morph(const Instance& instance) const {
   const Instance& result = Instance::Handle(Instance::New(to_));
   // Morph the context from instance to result using mapping_.
-  for (intptr_t i = 0; i < mapping_.length(); i +=2) {
+  for (intptr_t i = 0; i < mapping_.length(); i += 2) {
     intptr_t from_offset = mapping_.At(i);
-    intptr_t to_offset = mapping_.At(i+1);
+    intptr_t to_offset = mapping_.At(i + 1);
     const Object& value =
         Object::Handle(instance.RawGetFieldAtOffset(from_offset));
     result.RawSetFieldAtOffset(to_offset, value);
   }
   // Convert the instance into a filler object.
   Become::MakeDummyObject(instance);
   return result.raw();
 }
 
 
@@ skipping 18 matching lines @@
   for (intptr_t i = 0; i < fields.Length(); i++) {
     if (fields.At(i) != Field::null()) {
       field = Field::RawCast(fields.At(i));
       ASSERT(field.is_instance());
       name = field.name();
       THR_Print("  - @%" Pd " %s\n", field.Offset(), name.ToCString());
     }
   }
 
   THR_Print("Mapping: ");
-  for (int i = 0; i < mapping_.length(); i +=2) {
-    THR_Print(" %" Pd "->%" Pd,  mapping_.At(i),  mapping_.At(i+1));
+  for (int i = 0; i < mapping_.length(); i += 2) {
+    THR_Print(" %" Pd "->%" Pd, mapping_.At(i), mapping_.At(i + 1));
   }
   THR_Print("\n");
 }
 
 
 void InstanceMorpher::Dump() const {
   LogBlock blocker;
   THR_Print("Morphing from ");
   DumpFormatFor(from_);
   THR_Print("To ");
   DumpFormatFor(to_);
   THR_Print("\n");
 }
 
 
 void InstanceMorpher::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ShapeChangeMapping");
   jsobj.AddProperty("class", to_);
   jsobj.AddProperty("instanceCount", before()->length());
   JSONArray map(&jsobj, "fieldOffsetMappings");
   for (int i = 0; i < mapping_.length(); i += 2) {
     JSONArray pair(&map);
     pair.AddValue(mapping_.At(i));
-    pair.AddValue(mapping_.At(i+1));
+    pair.AddValue(mapping_.At(i + 1));
   }
 }
 
 
 void ReasonForCancelling::Report(IsolateReloadContext* context) {
   const Error& error = Error::Handle(ToError());
   context->ReportError(error);
 }
 
 
@@ skipping 16 matching lines @@
   const String& message = String::Handle(ToString());
   jsobj.AddProperty("message", message.ToCString());
 }
 
 
 ClassReasonForCancelling::ClassReasonForCancelling(Zone* zone,
                                                    const Class& from,
                                                    const Class& to)
     : ReasonForCancelling(zone),
       from_(Class::ZoneHandle(zone, from.raw())),
-      to_(Class::ZoneHandle(zone, to.raw())) {
-}
+      to_(Class::ZoneHandle(zone, to.raw())) {}
 
 
 void ClassReasonForCancelling::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ReasonForCancelling");
   jsobj.AddProperty("class", from_);
   const String& message = String::Handle(ToString());
   jsobj.AddProperty("message", message.ToCString());
 }
 
@@ skipping 11 matching lines @@
   static const char* Name() { return "ScriptUrlSetTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsString() || !b.IsString()) {
       return false;
     }
 
     return String::Cast(a).Equals(String::Cast(b));
   }
 
-  static uword Hash(const Object& obj) {
-    return String::Cast(obj).Hash();
-  }
+  static uword Hash(const Object& obj) { return String::Cast(obj).Hash(); }
 };
 
 
 class ClassMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "ClassMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsClass() || !b.IsClass()) {
@@ skipping 10 matching lines @@
 
 class LibraryMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "LibraryMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsLibrary() || !b.IsLibrary()) {
       return false;
     }
-    return IsolateReloadContext::IsSameLibrary(
-        Library::Cast(a), Library::Cast(b));
+    return IsolateReloadContext::IsSameLibrary(Library::Cast(a),
+                                               Library::Cast(b));
   }
 
-  static uword Hash(const Object& obj) {
-    return Library::Cast(obj).UrlHash();
-  }
+  static uword Hash(const Object& obj) { return Library::Cast(obj).UrlHash(); }
 };
 
 
 class BecomeMapTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "BecomeMapTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     return a.raw() == b.raw();
@@ skipping 50 matching lines @@
   if (!a_name.Equals(b_name)) {
     return false;
   }
 
   const Library& a_lib = Library::Handle(a.library());
   const Library& b_lib = Library::Handle(b.library());
   return IsSameLibrary(a_lib, b_lib);
 }
 
 
-bool IsolateReloadContext::IsSameLibrary(
-    const Library& a_lib, const Library& b_lib) {
+bool IsolateReloadContext::IsSameLibrary(const Library& a_lib,
+                                         const Library& b_lib) {
   const String& a_lib_url =
       String::Handle(a_lib.IsNull() ? String::null() : a_lib.url());
   const String& b_lib_url =
       String::Handle(b_lib.IsNull() ? String::null() : b_lib.url());
   return a_lib_url.Equals(b_lib_url);
 }
 
 
-IsolateReloadContext::IsolateReloadContext(Isolate* isolate,
-                                           JSONStream* js)
+IsolateReloadContext::IsolateReloadContext(Isolate* isolate, JSONStream* js)
     : zone_(Thread::Current()->zone()),
       start_time_micros_(OS::GetCurrentMonotonicMicros()),
       reload_timestamp_(OS::GetCurrentTimeMillis()),
       isolate_(isolate),
       reload_skipped_(false),
       reload_aborted_(false),
       reload_finalized_(false),
       js_(js),
       saved_num_cids_(-1),
       saved_class_table_(NULL),
@@ skipping 12 matching lines @@
       become_enum_mappings_(GrowableObjectArray::null()),
       saved_root_library_(Library::null()),
       saved_libraries_(GrowableObjectArray::null()) {
   // NOTE: DO NOT ALLOCATE ANY RAW OBJECTS HERE. The IsolateReloadContext is not
   // associated with the isolate yet and if a GC is triggered here the raw
   // objects will not be properly accounted for.
   ASSERT(zone_ != NULL);
 }
 
 
-IsolateReloadContext::~IsolateReloadContext() {
-}
+IsolateReloadContext::~IsolateReloadContext() {}
 
 
 void IsolateReloadContext::ReportError(const Error& error) {
   if (FLAG_trace_reload) {
     THR_Print("ISO-RELOAD: Error: %s\n", error.ToErrorCString());
   }
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   service_event.set_reload_error(&error);
   Service::HandleEvent(&service_event);
 }
 
 
 void IsolateReloadContext::ReportSuccess() {
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   Service::HandleEvent(&service_event);
 }
 
 
 class Aborted : public ReasonForCancelling {
  public:
   Aborted(Zone* zone, const Error& error)
       : ReasonForCancelling(zone),
-        error_(Error::ZoneHandle(zone, error.raw())) {
-  }
+        error_(Error::ZoneHandle(zone, error.raw())) {}
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
   RawString* ToString() {
     return String::NewFormatted("%s", error_.ToErrorCString());
   }
 };
 
@@ skipping 17 matching lines @@
     ReportOnJSON(js_);
     TIR_Print("---- SKIPPING RELOAD (No libraries were modified)\n");
     return;
   }
 
   TIR_Print("---- STARTING RELOAD\n");
 
   // Preallocate storage for maps.
   old_classes_set_storage_ =
       HashTables::New<UnorderedHashSet<ClassMapTraits> >(4);
-  class_map_storage_ =
-      HashTables::New<UnorderedHashMap<ClassMapTraits> >(4);
+  class_map_storage_ = HashTables::New<UnorderedHashMap<ClassMapTraits> >(4);
   old_libraries_set_storage_ =
       HashTables::New<UnorderedHashSet<LibraryMapTraits> >(4);
   library_map_storage_ =
       HashTables::New<UnorderedHashMap<LibraryMapTraits> >(4);
-  become_map_storage_ =
-      HashTables::New<UnorderedHashMap<BecomeMapTraits> >(4);
+  become_map_storage_ = HashTables::New<UnorderedHashMap<BecomeMapTraits> >(4);
   // Keep a separate array for enum mappings to avoid having to invoke
   // hashCode on the instances.
   become_enum_mappings_ = GrowableObjectArray::New(Heap::kOld);
 
   // Disable the background compiler while we are performing the reload.
   BackgroundCompiler::Disable();
 
   // Ensure all functions on the stack have unoptimized code.
   EnsuredUnoptimizedCodeForStack();
   // Deoptimize all code that had optimizing decisions that are dependent on
@@ skipping 20 matching lines @@
   // Even after a successful reload the Dart code invoked in (5) can result
   // in an Unwind error or an UnhandledException error. This error will be
   // returned by the tag handler. The tag handler can return other errors,
   // for example, top level parse errors. We want to capture these errors while
   // propagating the UnwindError or an UnhandledException error.
   Object& result = Object::Handle(thread->zone());
   {
     TransitionVMToNative transition(thread);
     Api::Scope api_scope(thread);
 
-    Dart_Handle retval =
-        (I->library_tag_handler())(Dart_kScriptTag,
-                                   Api::NewHandle(thread, Library::null()),
-                                   Api::NewHandle(thread, root_lib_url.raw()));
+    Dart_Handle retval = (I->library_tag_handler())(
+        Dart_kScriptTag, Api::NewHandle(thread, Library::null()),
+        Api::NewHandle(thread, root_lib_url.raw()));
     result = Api::UnwrapHandle(retval);
   }
   //
   // WEIRD CONTROL FLOW ENDS.
 
   BackgroundCompiler::Enable();
 
-  if (result.IsUnwindError() ||
-      result.IsUnhandledException()) {
+  if (result.IsUnwindError() || result.IsUnhandledException()) {
     // If the tag handler returns with an UnwindError or an UnhandledException
     // error, propagate it and give up.
     Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
 
   // Other errors (e.g. a parse error) are captured by the reload system.
   if (result.IsError()) {
     FinalizeFailedLoad(Error::Cast(result));
   }
@@ skipping 175 matching lines @@
   // Copy the size of the class table.
   saved_num_cids_ = I->class_table()->NumCids();
 
   // Copy of the class table.
   RawClass** local_saved_class_table =
       reinterpret_cast<RawClass**>(malloc(sizeof(RawClass*) * saved_num_cids_));
 
   Class& cls = Class::Handle();
   UnorderedHashSet<ClassMapTraits> old_classes_set(old_classes_set_storage_);
   for (intptr_t i = 0; i < saved_num_cids_; i++) {
-    if (class_table->IsValidIndex(i) &&
-        class_table->HasValidClassAt(i)) {
+    if (class_table->IsValidIndex(i) && class_table->HasValidClassAt(i)) {
       // Copy the class into the saved class table and add it to the set.
       local_saved_class_table[i] = class_table->At(i);
       if (i != kFreeListElement && i != kForwardingCorpse) {
         cls = class_table->At(i);
         bool already_present = old_classes_set.Insert(cls);
         ASSERT(!already_present);
       }
     } else {
       // No class at this index, mark it as NULL.
       local_saved_class_table[i] = NULL;
@@ skipping 15 matching lines @@
     return true;
   }
   // We use the resolved url to determine if the script has been modified.
   const String& url = String::Handle(script.resolved_url());
   const char* url_chars = url.ToCString();
   return (*file_modified_callback_)(url_chars, since);
 }
 
 
 static void PropagateLibraryModified(
-    const ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >* imported_by,
+    const ZoneGrowableArray<ZoneGrowableArray<intptr_t>*>* imported_by,
     intptr_t lib_index,
     BitVector* modified_libs) {
   ZoneGrowableArray<intptr_t>* dep_libs = (*imported_by)[lib_index];
   for (intptr_t i = 0; i < dep_libs->length(); i++) {
     intptr_t dep_lib_index = (*dep_libs)[i];
     if (!modified_libs->Contains(dep_lib_index)) {
       modified_libs->Add(dep_lib_index);
       PropagateLibraryModified(imported_by, dep_lib_index, modified_libs);
     }
   }
 }
 
 
 BitVector* IsolateReloadContext::FindModifiedLibraries(bool force_reload) {
   Thread* thread = Thread::Current();
   int64_t last_reload = I->last_reload_timestamp();
 
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
   Library& lib = Library::Handle();
   Array& scripts = Array::Handle();
   Script& script = Script::Handle();
   intptr_t num_libs = libs.Length();
 
   // Construct the imported-by graph.
-  ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >* imported_by =
-      new(zone_) ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >(
-          zone_, num_libs);
+  ZoneGrowableArray<ZoneGrowableArray<intptr_t>*>* imported_by = new (zone_)
+      ZoneGrowableArray<ZoneGrowableArray<intptr_t>*>(zone_, num_libs);
   imported_by->SetLength(num_libs);
   for (intptr_t i = 0; i < num_libs; i++) {
-    (*imported_by)[i] = new(zone_) ZoneGrowableArray<intptr_t>(zone_, 0);
+    (*imported_by)[i] = new (zone_) ZoneGrowableArray<intptr_t>(zone_, 0);
   }
   Array& ports = Array::Handle();
   Namespace& ns = Namespace::Handle();
   Library& target = Library::Handle();
 
   for (intptr_t lib_idx = 0; lib_idx < num_libs; lib_idx++) {
     lib ^= libs.At(lib_idx);
     ASSERT(lib_idx == lib.index());
     if (lib.is_dart_scheme()) {
       // We don't care about imports among dart scheme libraries.
@@ skipping 34 matching lines @@
           ns ^= ports.At(import_idx);
           if (!ns.IsNull()) {
             target = ns.library();
             (*imported_by)[target.index()]->Add(lib.index());
           }
         }
       }
     }
   }
 
-  BitVector* modified_libs = new(Z) BitVector(Z, num_libs);
+  BitVector* modified_libs = new (Z) BitVector(Z, num_libs);
 
   for (intptr_t lib_idx = 0; lib_idx < num_libs; lib_idx++) {
     lib ^= libs.At(lib_idx);
     if (lib.is_dart_scheme() || modified_libs->Contains(lib_idx)) {
       // We don't consider dart scheme libraries during reload.  If
       // the modified libs set already contains this library, then we
       // have already visited it.
       continue;
     }
     scripts = lib.LoadedScripts();
     for (intptr_t script_idx = 0; script_idx < scripts.Length(); script_idx++) {
       script ^= scripts.At(script_idx);
       if (force_reload || ScriptModifiedSince(script, last_reload)) {
         modified_libs->Add(lib_idx);
         PropagateLibraryModified(imported_by, lib_idx, modified_libs);
         break;
       }
     }
   }
 
   return modified_libs;
 }
 
 
 void IsolateReloadContext::CheckpointLibraries() {
   TIMELINE_SCOPE(CheckpointLibraries);
   TIR_Print("---- CHECKPOINTING LIBRARIES\n");
   // Save the root library in case we abort the reload.
-  const Library& root_lib =
-      Library::Handle(object_store()->root_library());
+  const Library& root_lib = Library::Handle(object_store()->root_library());
   set_saved_root_library(root_lib);
 
   // Save the old libraries array in case we abort the reload.
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
   set_saved_libraries(libs);
 
   // Make a filtered copy of the old libraries array. Keep "clean" libraries
   // that we will use instead of reloading.
-  const GrowableObjectArray& new_libs = GrowableObjectArray::Handle(
-      GrowableObjectArray::New(Heap::kOld));
+  const GrowableObjectArray& new_libs =
+      GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   Library& lib = Library::Handle();
-  UnorderedHashSet<LibraryMapTraits>
-      old_libraries_set(old_libraries_set_storage_);
+  UnorderedHashSet<LibraryMapTraits> old_libraries_set(
+      old_libraries_set_storage_);
   num_saved_libs_ = 0;
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     if (modified_libs_->Contains(i)) {
       // We are going to reload this library. Clear the index.
       lib.set_index(-1);
     } else {
       // We are preserving this library across the reload, assign its new index
       lib.set_index(new_libs.Length());
       new_libs.Add(lib, Heap::kOld);
@@ skipping 42 matching lines @@
   // be suspended between loading the table pointer and loading the table
   // element. Table will be freed at the next major GC or isolate shutdown.
   class_table->AddOldTable(local_saved_class_table);
 }
 
 
 void IsolateReloadContext::RollbackLibraries() {
   TIR_Print("---- ROLLING BACK LIBRARY CHANGES\n");
   Thread* thread = Thread::Current();
   Library& lib = Library::Handle();
-  GrowableObjectArray& saved_libs = GrowableObjectArray::Handle(
-      Z, saved_libraries());
+  GrowableObjectArray& saved_libs =
+      GrowableObjectArray::Handle(Z, saved_libraries());
   if (!saved_libs.IsNull()) {
     for (intptr_t i = 0; i < saved_libs.Length(); i++) {
       lib = Library::RawCast(saved_libs.At(i));
       // Restore indexes that were modified in CheckpointLibraries.
       lib.set_index(i);
     }
 
     // Reset the registered libraries to the filtered array.
     Library::RegisterLibraries(thread, saved_libs);
   }
@@ skipping 20 matching lines @@
   TIMELINE_SCOPE(VerifyMaps);
   Class& cls = Class::Handle();
   Class& new_cls = Class::Handle();
   Class& cls2 = Class::Handle();
 
   // Verify that two old classes aren't both mapped to the same new
   // class. This could happen is the IsSameClass function is broken.
   UnorderedHashMap<ClassMapTraits> class_map(class_map_storage_);
   UnorderedHashMap<ClassMapTraits> reverse_class_map(
       HashTables::New<UnorderedHashMap<ClassMapTraits> >(
-         class_map.NumOccupied()));
+          class_map.NumOccupied()));
   {
     UnorderedHashMap<ClassMapTraits>::Iterator it(&class_map);
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       new_cls = Class::RawCast(class_map.GetKey(entry));
       cls = Class::RawCast(class_map.GetPayload(entry, 0));
       cls2 ^= reverse_class_map.GetOrNull(new_cls);
       if (!cls2.IsNull()) {
-        OS::PrintErr("Classes '%s' and '%s' are distinct classes but both map "
-                     " to class '%s'\n",
-                     cls.ToCString(), cls2.ToCString(), new_cls.ToCString());
+        OS::PrintErr(
+            "Classes '%s' and '%s' are distinct classes but both map "
+            " to class '%s'\n",
+            cls.ToCString(), cls2.ToCString(), new_cls.ToCString());
         UNREACHABLE();
       }
       bool update = reverse_class_map.UpdateOrInsert(cls, new_cls);
       ASSERT(!update);
     }
   }
   class_map.Release();
   reverse_class_map.Release();
 }
 #endif
@@ skipping 74 matching lines @@
     }
 
     // Release the library map.
     lib_map.Release();
   }
 
   {
     TIMELINE_SCOPE(UpdateLibrariesArray);
     // Update the libraries array.
     Library& lib = Library::Handle();
-    const GrowableObjectArray& libs = GrowableObjectArray::Handle(
-        I->object_store()->libraries());
+    const GrowableObjectArray& libs =
+        GrowableObjectArray::Handle(I->object_store()->libraries());
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib = Library::RawCast(libs.At(i));
       VTIR_Print("Lib '%s' at index %" Pd "\n", lib.ToCString(), i);
       lib.set_index(i);
     }
 
     // Initialize library side table.
     library_infos_.SetLength(libs.Length());
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib = Library::RawCast(libs.At(i));
       // Mark the library dirty if it comes after the libraries we saved.
       library_infos_[i].dirty = i >= num_saved_libs_;
     }
   }
 
   {
     const GrowableObjectArray& become_enum_mappings =
         GrowableObjectArray::Handle(become_enum_mappings_);
     UnorderedHashMap<BecomeMapTraits> become_map(become_map_storage_);
-    intptr_t replacement_count = become_map.NumOccupied() +
-                                 become_enum_mappings.Length() / 2;
+    intptr_t replacement_count =
+        become_map.NumOccupied() + become_enum_mappings.Length() / 2;
     const Array& before =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
     const Array& after =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
     Object& obj = Object::Handle();
     intptr_t replacement_index = 0;
     UnorderedHashMap<BecomeMapTraits>::Iterator it(&become_map);
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       obj = become_map.GetKey(entry);
@@ skipping 11 matching lines @@
     }
     ASSERT(replacement_index == replacement_count);
     become_map.Release();
 
     Become::ElementsForwardIdentity(before, after);
   }
 
   if (FLAG_identity_reload) {
     if (saved_num_cids_ != I->class_table()->NumCids()) {
       TIR_Print("Identity reload failed! B#C=%" Pd " A#C=%" Pd "\n",
-                saved_num_cids_,
-                I->class_table()->NumCids());
+                saved_num_cids_, I->class_table()->NumCids());
     }
     const GrowableObjectArray& saved_libs =
         GrowableObjectArray::Handle(saved_libraries());
     const GrowableObjectArray& libs =
         GrowableObjectArray::Handle(I->object_store()->libraries());
     if (saved_libs.Length() != libs.Length()) {
-     TIR_Print("Identity reload failed! B#L=%" Pd " A#L=%" Pd "\n",
-               saved_libs.Length(),
-               libs.Length());
+      TIR_Print("Identity reload failed! B#L=%" Pd " A#L=%" Pd "\n",
+                saved_libs.Length(), libs.Length());
     }
   }
 }
 
 
 bool IsolateReloadContext::IsDirty(const Library& lib) {
   const intptr_t index = lib.index();
   if (index == static_cast<classid_t>(-1)) {
     // Treat deleted libraries as dirty.
     return true;
@@ skipping 30 matching lines @@
     reasons_to_cancel_reload_.At(i)->Report(this);
   }
 }
 
 
 // The ObjectLocator is used for collecting instances that
 // needs to be morphed.
 class ObjectLocator : public ObjectVisitor {
  public:
   explicit ObjectLocator(IsolateReloadContext* context)
-      : context_(context), count_(0) {
-  }
+      : context_(context), count_(0) {}
 
   void VisitObject(RawObject* obj) {
     InstanceMorpher* morpher =
         context_->cid_mapper_.LookupValue(obj->GetClassId());
     if (morpher != NULL) {
       morpher->AddObject(obj);
       count_++;
     }
   }
 
@@ skipping 18 matching lines @@
   }
 
   // Find all objects that need to be morphed.
   ObjectLocator locator(this);
   isolate()->heap()->VisitObjects(&locator);
 
   // Return if no objects are located.
   intptr_t count = locator.count();
   if (count == 0) return;
 
-  TIR_Print("Found %" Pd " object%s subject to morphing.\n",
-            count, (count > 1) ? "s" : "");
+  TIR_Print("Found %" Pd " object%s subject to morphing.\n", count,
+            (count > 1) ? "s" : "");
 
   Array& before = Array::Handle();
   Array& after = Array::Handle();
-  { // Prevent GC to take place due object format confusion.
+  {  // Prevent GC to take place due object format confusion.
     // Hint: More than one class share the same cid.
     NoHeapGrowthControlScope scope;
     for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
       instance_morphers_.At(i)->CreateMorphedCopies();
     }
     // Create the inputs for Become.
     intptr_t index = 0;
     before = Array::New(count);
     after = Array::New(count);
     for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
@@ skipping 148 matching lines @@
   // the current megamorphic caches get GC'd and any new optimized code allocate
   // new ones.
 }
 
 
 class MarkFunctionsForRecompilation : public ObjectVisitor {
  public:
   MarkFunctionsForRecompilation(Isolate* isolate,
                                 IsolateReloadContext* reload_context,
                                 Zone* zone)
-    : ObjectVisitor(),
-      handle_(Object::Handle(zone)),
-      owning_class_(Class::Handle(zone)),
-      owning_lib_(Library::Handle(zone)),
-      code_(Code::Handle(zone)),
-      reload_context_(reload_context),
-      zone_(zone) {
-  }
+      : ObjectVisitor(),
+        handle_(Object::Handle(zone)),
+        owning_class_(Class::Handle(zone)),
+        owning_lib_(Library::Handle(zone)),
+        code_(Code::Handle(zone)),
+        reload_context_(reload_context),
+        zone_(zone) {}
 
   virtual void VisitObject(RawObject* obj) {
     if (obj->IsPseudoObject()) {
       // Cannot even be wrapped in handles.
       return;
     }
     handle_ = obj;
     if (handle_.IsFunction()) {
       const Function& func = Function::Cast(handle_);
 
       // Switch to unoptimized code or the lazy compilation stub.
       func.SwitchToLazyCompiledUnoptimizedCode();
 
       // Grab the current code.
       code_ = func.CurrentCode();
       ASSERT(!code_.IsNull());
       const bool clear_code = IsFromDirtyLibrary(func);
       const bool stub_code = code_.IsStubCode();
 
       // Zero edge counters.
       func.ZeroEdgeCounters();
 
       if (!stub_code) {
         if (clear_code) {
           VTIR_Print("Marking %s for recompilation, clearning code\n",
-              func.ToCString());
+                     func.ToCString());
           ClearAllCode(func);
         } else {
           PreserveUnoptimizedCode();
         }
       }
 
       // Clear counters.
       func.set_usage_counter(0);
       func.set_deoptimization_counter(0);
       func.set_optimized_instruction_count(0);
@@ skipping 84 matching lines @@
   const Library& old = Library::Handle(OldLibraryOrNull(replacement_or_new));
   if (old.IsNull()) {
     return String::null();
   }
   return old.private_key();
 }
 
 
 RawLibrary* IsolateReloadContext::OldLibraryOrNull(
     const Library& replacement_or_new) {
-  UnorderedHashSet<LibraryMapTraits>
-      old_libraries_set(old_libraries_set_storage_);
+  UnorderedHashSet<LibraryMapTraits> old_libraries_set(
+      old_libraries_set_storage_);
   Library& lib = Library::Handle();
   lib ^= old_libraries_set.GetOrNull(replacement_or_new);
   old_libraries_set.Release();
   return lib.raw();
 }
 
 
 void IsolateReloadContext::BuildLibraryMapping() {
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
@@ skipping 37 matching lines @@
                                              const Library& original) {
   UnorderedHashMap<LibraryMapTraits> map(library_map_storage_);
   bool update = map.UpdateOrInsert(replacement_or_new, original);
   ASSERT(!update);
   // The storage given to the map may have been reallocated, remember the new
   // address.
   library_map_storage_ = map.Release().raw();
 }
 
 
-void IsolateReloadContext::AddStaticFieldMapping(
-    const Field& old_field, const Field& new_field) {
+void IsolateReloadContext::AddStaticFieldMapping(const Field& old_field,
+                                                 const Field& new_field) {
   ASSERT(old_field.is_static());
   ASSERT(new_field.is_static());
 
   AddBecomeMapping(old_field, new_field);
 }
 
 
 void IsolateReloadContext::AddBecomeMapping(const Object& old,
                                             const Object& neu) {
   ASSERT(become_map_storage_ != Array::null());
@@ skipping 43 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart