clang-format runtime/vm

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 31 matching lines @@
 #include "vm/tags.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/type_table.h"
 #include "vm/unicode.h"
 #include "vm/weak_code.h"
 
 namespace dart {
 
-DEFINE_FLAG(int, huge_method_cutoff_in_code_size, 200000,
-    "Huge method cutoff in unoptimized code size (in bytes).");
-DEFINE_FLAG(bool, overlap_type_arguments, true,
+DEFINE_FLAG(int,
+            huge_method_cutoff_in_code_size,
+            200000,
+            "Huge method cutoff in unoptimized code size (in bytes).");
+DEFINE_FLAG(
+    bool,
+    overlap_type_arguments,
+    true,
     "When possible, partially or fully overlap the type arguments of a type "
     "with the type arguments of its super type.");
-DEFINE_FLAG(bool, show_internal_names, false,
+DEFINE_FLAG(
+    bool,
+    show_internal_names,
+    false,
     "Show names of internal classes (e.g. \"OneByteString\") in error messages "
     "instead of showing the corresponding interface names (e.g. \"String\")");
 DEFINE_FLAG(bool, use_lib_cache, true, "Use library name cache");
 DEFINE_FLAG(bool, use_exp_cache, true, "Use library exported name cache");
-DEFINE_FLAG(bool, ignore_patch_signature_mismatch, false,
+DEFINE_FLAG(bool,
+            ignore_patch_signature_mismatch,
+            false,
             "Ignore patch file member signature mismatch.");
 
-DEFINE_FLAG(bool, remove_script_timestamps_for_test, false,
+DEFINE_FLAG(bool,
+            remove_script_timestamps_for_test,
+            false,
             "Remove script timestamps to allow for deterministic testing.");
 
 DECLARE_FLAG(bool, show_invisible_frames);
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
 DECLARE_FLAG(bool, trace_reload);
 DECLARE_FLAG(bool, write_protect_code);
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 static const char* const kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* const kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 
 // A cache of VM heap allocated preinitialized empty ic data entry arrays.
 RawArray* ICData::cached_icdata_arrays_[kCachedICDataArrayCount];
 
 cpp_vtable Object::handle_vtable_ = 0;
-cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
+cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = {0};
 cpp_vtable Smi::handle_vtable_ = 0;
 
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
@@ skipping 69 matching lines @@
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unwind_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 
 
 const double MegamorphicCache::kLoadFactor = 0.50;
 
 
 static void AppendSubString(Zone* zone,
                             GrowableArray<const char*>* segments,
                             const char* name,
-                            intptr_t start_pos, intptr_t len) {
+                            intptr_t start_pos,
+                            intptr_t len) {
   char* segment = zone->Alloc<char>(len + 1);  // '\0'-terminated.
   memmove(segment, name + start_pos, len);
   segment[len] = '\0';
   segments->Add(segment);
 }
 
 
 static const char* MergeSubStrings(Zone* zone,
                                    const GrowableArray<const char*>& segments,
                                    intptr_t alloc_len) {
@@ skipping 34 matching lines @@
 // And so forth:
 //
 //   get:foo@6328321 -> foo
 //   _MyClass@6328321. -> _MyClass
 //   _MyClass@6328321.named -> _MyClass.named
 //
 RawString* String::ScrubName(const String& name) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   if (name.Equals(Symbols::TopLevel())) {
     // Name of invisible top-level class.
     return Symbols::Empty().raw();
   }
-)
+#endif  // !defined(PRODUCT)
 
   const char* cname = name.ToCString();
   ASSERT(strlen(cname) == static_cast<size_t>(name.Length()));
   const intptr_t name_len = name.Length();
   // First remove all private name mangling.
   intptr_t start_pos = 0;
   GrowableArray<const char*> unmangled_segments;
   intptr_t sum_segment_len = 0;
   for (intptr_t i = 0; i < name_len; i++) {
-    if ((cname[i] == '@') && ((i + 1) < name_len) &&
-        (cname[i + 1] >= '0') && (cname[i + 1] <= '9')) {
+    if ((cname[i] == '@') && ((i + 1) < name_len) && (cname[i + 1] >= '0') &&
+        (cname[i + 1] <= '9')) {
       // Append the current segment to the unmangled name.
       const intptr_t segment_len = i - start_pos;
       sum_segment_len += segment_len;
       AppendSubString(zone, &unmangled_segments, cname, start_pos, segment_len);
       // Advance until past the name mangling. The private keys are only
       // numbers so we skip until the first non-number.
       i++;  // Skip the '@'.
-      while ((i < name.Length()) &&
-             (name.CharAt(i) >= '0') &&
+      while ((i < name.Length()) && (name.CharAt(i) >= '0') &&
              (name.CharAt(i) <= '9')) {
         i++;
       }
       start_pos = i;
       i--;  // Account for for-loop increment.
     }
   }
 
   const char* unmangled_name = NULL;
   if (start_pos == 0) {
     // No name unmangling needed, reuse the name that was passed in.
     unmangled_name = cname;
     sum_segment_len = name_len;
   } else if (name.Length() != start_pos) {
     // Append the last segment.
     const intptr_t segment_len = name.Length() - start_pos;
     sum_segment_len += segment_len;
     AppendSubString(zone, &unmangled_segments, cname, start_pos, segment_len);
   }
   if (unmangled_name == NULL) {
     // Merge unmangled_segments.
     unmangled_name = MergeSubStrings(zone, unmangled_segments, sum_segment_len);
   }
 
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   intptr_t len = sum_segment_len;
   intptr_t start = 0;
   intptr_t dot_pos = -1;  // Position of '.' in the name, if any.
   bool is_setter = false;
   for (intptr_t i = start; i < len; i++) {
     if (unmangled_name[i] == ':') {
       if (start != 0) {
         // Reset and break.
         start = 0;
         dot_pos = -1;
@@ skipping 28 matching lines @@
   intptr_t final_len = end - start;
   AppendSubString(zone, &unmangled_segments, unmangled_name, start, final_len);
   if (is_setter) {
     const char* equals = Symbols::Equals().ToCString();
     const intptr_t equals_len = strlen(equals);
     AppendSubString(zone, &unmangled_segments, equals, 0, equals_len);
     final_len += equals_len;
   }
 
   unmangled_name = MergeSubStrings(zone, unmangled_segments, final_len);
-)
+#endif  // !defined(PRODUCT)
 
   return Symbols::New(thread, unmangled_name);
 }
 
 
 RawString* String::ScrubNameRetainPrivate(const String& name) {
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   intptr_t len = name.Length();
   intptr_t start = 0;
   intptr_t at_pos = -1;  // Position of '@' in the name, if any.
   bool is_setter = false;
 
   for (intptr_t i = start; i < len; i++) {
     if (name.CharAt(i) == ':') {
       ASSERT(start == 0);  // Only one : is possible in getters or setters.
       if (name.CharAt(0) == 's') {
         is_setter = true;
@@ skipping 22 matching lines @@
       const String& pre_at =
           String::Handle(String::SubString(result, 0, at_pos - 4));
       const String& post_at =
           String::Handle(String::SubString(name, at_pos, len - at_pos));
       result = String::Concat(pre_at, Symbols::Equals());
       result = String::Concat(result, post_at);
     }
   }
 
   return result.raw();
-)
+#endif                // !defined(PRODUCT)
   return name.raw();  // In PRODUCT, return argument unchanged.
 }
 
 
-template<typename type>
+template <typename type>
 static bool IsSpecialCharacter(type value) {
-  return ((value == '"') ||
-          (value == '\n') ||
-          (value == '\f') ||
-          (value == '\b') ||
-          (value == '\t') ||
-          (value == '\v') ||
-          (value == '\r') ||
-          (value == '\\') ||
-          (value == '$'));
+  return ((value == '"') || (value == '\n') || (value == '\f') ||
+          (value == '\b') || (value == '\t') || (value == '\v') ||
+          (value == '\r') || (value == '\\') || (value == '$'));
 }
 
 
 static inline bool IsAsciiNonprintable(int32_t c) {
   return ((0 <= c) && (c < 32)) || (c == 127);
 }
 
 
 static inline bool NeedsEscapeSequence(int32_t c) {
-  return (c == '"')  ||
-         (c == '\\') ||
-         (c == '$')  ||
-         IsAsciiNonprintable(c);
+  return (c == '"') || (c == '\\') || (c == '$') || IsAsciiNonprintable(c);
 }
 
 
 static int32_t EscapeOverhead(int32_t c) {
   if (IsSpecialCharacter(c)) {
     return 1;  // 1 additional byte for the backslash.
   } else if (IsAsciiNonprintable(c)) {
     return 3;  // 3 additional bytes to encode c as \x00.
   }
   return 0;
 }
 
 
-template<typename type>
+template <typename type>
 static type SpecialCharacter(type value) {
   if (value == '"') {
     return '"';
   } else if (value == '\n') {
     return 'n';
   } else if (value == '\f') {
     return 'f';
   } else if (value == '\b') {
     return 'b';
   } else if (value == '\t') {
@@ skipping 57 matching lines @@
   zero_array_ = Array::ReadOnlyHandle();
   empty_context_scope_ = ContextScope::ReadOnlyHandle();
   empty_object_pool_ = ObjectPool::ReadOnlyHandle();
   empty_descriptors_ = PcDescriptors::ReadOnlyHandle();
   empty_var_descriptors_ = LocalVarDescriptors::ReadOnlyHandle();
   empty_exception_handlers_ = ExceptionHandlers::ReadOnlyHandle();
   extractor_parameter_types_ = Array::ReadOnlyHandle();
   extractor_parameter_names_ = Array::ReadOnlyHandle();
   sentinel_ = Instance::ReadOnlyHandle();
   transition_sentinel_ = Instance::ReadOnlyHandle();
-  unknown_constant_ =  Instance::ReadOnlyHandle();
-  non_constant_ =  Instance::ReadOnlyHandle();
+  unknown_constant_ = Instance::ReadOnlyHandle();
+  non_constant_ = Instance::ReadOnlyHandle();
   bool_true_ = Bool::ReadOnlyHandle();
   bool_false_ = Bool::ReadOnlyHandle();
   smi_illegal_cid_ = Smi::ReadOnlyHandle();
   snapshot_writer_error_ = LanguageError::ReadOnlyHandle();
   branch_offset_error_ = LanguageError::ReadOnlyHandle();
   speculative_inlining_error_ = LanguageError::ReadOnlyHandle();
   background_compilation_error_ = LanguageError::ReadOnlyHandle();
   vm_isolate_snapshot_object_table_ = Array::ReadOnlyHandle();
   dynamic_type_ = Type::ReadOnlyHandle();
   void_type_ = Type::ReadOnlyHandle();
@@ skipping 206 matching lines @@
   Class::NewExternalTypedDataClass(kExternalTypedDataUint8ArrayCid);
 
   // Needed for object pools of VM isolate stubs.
   Class::NewTypedDataClass(kTypedDataInt8ArrayCid);
 
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kImmutableArrayCid, Array::InstanceSize(0), true);
     Array::initializeHandle(
-        empty_array_,
-        reinterpret_cast<RawArray*>(address + kHeapObjectTag));
+        empty_array_, reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->StoreSmi(&empty_array_->raw_ptr()->length_, Smi::New(0));
     empty_array_->SetCanonical();
   }
 
   Smi& smi = Smi::Handle();
   // Allocate and initialize the zero_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(1), Heap::kOld);
     InitializeObject(address, kImmutableArrayCid, Array::InstanceSize(1), true);
     Array::initializeHandle(
-        zero_array_,
-        reinterpret_cast<RawArray*>(address + kHeapObjectTag));
+        zero_array_, reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     zero_array_->StoreSmi(&zero_array_->raw_ptr()->length_, Smi::New(1));
     smi = Smi::New(0);
     zero_array_->SetAt(0, smi);
     zero_array_->SetCanonical();
   }
 
   // Allocate and initialize the canonical empty context scope object.
   {
     uword address = heap->Allocate(ContextScope::InstanceSize(0), Heap::kOld);
-    InitializeObject(address,
-                     kContextScopeCid,
-                     ContextScope::InstanceSize(0),
+    InitializeObject(address, kContextScopeCid, ContextScope::InstanceSize(0),
                      true);
     ContextScope::initializeHandle(
         empty_context_scope_,
         reinterpret_cast<RawContextScope*>(address + kHeapObjectTag));
     empty_context_scope_->StoreNonPointer(
         &empty_context_scope_->raw_ptr()->num_variables_, 0);
     empty_context_scope_->StoreNonPointer(
         &empty_context_scope_->raw_ptr()->is_implicit_, true);
     empty_context_scope_->SetCanonical();
   }
 
   // Allocate and initialize the canonical empty object pool object.
   {
-    uword address =
-        heap->Allocate(ObjectPool::InstanceSize(0), Heap::kOld);
-    InitializeObject(address,
-                     kObjectPoolCid,
-                     ObjectPool::InstanceSize(0),
+    uword address = heap->Allocate(ObjectPool::InstanceSize(0), Heap::kOld);
+    InitializeObject(address, kObjectPoolCid, ObjectPool::InstanceSize(0),
                      true);
     ObjectPool::initializeHandle(
         empty_object_pool_,
         reinterpret_cast<RawObjectPool*>(address + kHeapObjectTag));
-    empty_object_pool_->StoreNonPointer(
-        &empty_object_pool_->raw_ptr()->length_, 0);
+    empty_object_pool_->StoreNonPointer(&empty_object_pool_->raw_ptr()->length_,
+                                        0);
     empty_object_pool_->SetCanonical();
   }
 
   // Allocate and initialize the empty_descriptors instance.
   {
     uword address = heap->Allocate(PcDescriptors::InstanceSize(0), Heap::kOld);
-    InitializeObject(address, kPcDescriptorsCid,
-                     PcDescriptors::InstanceSize(0),
+    InitializeObject(address, kPcDescriptorsCid, PcDescriptors::InstanceSize(0),
                      true);
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
     empty_descriptors_->StoreNonPointer(&empty_descriptors_->raw_ptr()->length_,
                                         0);
     empty_descriptors_->SetCanonical();
   }
 
   // Allocate and initialize the canonical empty variable descriptor object.
   {
     uword address =
         heap->Allocate(LocalVarDescriptors::InstanceSize(0), Heap::kOld);
-    InitializeObject(address,
-                     kLocalVarDescriptorsCid,
-                     LocalVarDescriptors::InstanceSize(0),
-                     true);
+    InitializeObject(address, kLocalVarDescriptorsCid,
+                     LocalVarDescriptors::InstanceSize(0), true);
     LocalVarDescriptors::initializeHandle(
         empty_var_descriptors_,
         reinterpret_cast<RawLocalVarDescriptors*>(address + kHeapObjectTag));
     empty_var_descriptors_->StoreNonPointer(
         &empty_var_descriptors_->raw_ptr()->num_entries_, 0);
     empty_var_descriptors_->SetCanonical();
   }
 
   // Allocate and initialize the canonical empty exception handler info object.
   // The vast majority of all functions do not contain an exception handler
   // and can share this canonical descriptor.
   {
     uword address =
         heap->Allocate(ExceptionHandlers::InstanceSize(0), Heap::kOld);
-    InitializeObject(address,
-                     kExceptionHandlersCid,
-                     ExceptionHandlers::InstanceSize(0),
-                     true);
+    InitializeObject(address, kExceptionHandlersCid,
+                     ExceptionHandlers::InstanceSize(0), true);
     ExceptionHandlers::initializeHandle(
         empty_exception_handlers_,
         reinterpret_cast<RawExceptionHandlers*>(address + kHeapObjectTag));
     empty_exception_handlers_->StoreNonPointer(
         &empty_exception_handlers_->raw_ptr()->num_entries_, 0);
     empty_exception_handlers_->SetCanonical();
   }
 
   // The VM isolate snapshot object table is initialized to an empty array
   // as we do not have any VM isolate snapshot at this time.
@@ skipping 27 matching lines @@
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
   *smi_illegal_cid_ = Smi::New(kIllegalCid);
 
   String& error_str = String::Handle();
   error_str = String::New("SnapshotWriter Error", Heap::kOld);
-  *snapshot_writer_error_ = LanguageError::New(error_str,
-                                               Report::kError,
-                                               Heap::kOld);
+  *snapshot_writer_error_ =
+      LanguageError::New(error_str, Report::kError, Heap::kOld);
   error_str = String::New("Branch offset overflow", Heap::kOld);
-  *branch_offset_error_ = LanguageError::New(error_str,
-                                             Report::kBailout,
-                                             Heap::kOld);
+  *branch_offset_error_ =
+      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
   error_str = String::New("Speculative inlining failed", Heap::kOld);
-  *speculative_inlining_error_ = LanguageError::New(error_str,
-                                                    Report::kBailout,
-                                                    Heap::kOld);
+  *speculative_inlining_error_ =
+      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
   error_str = String::New("Background Compilation Failed", Heap::kOld);
-  *background_compilation_error_ = LanguageError::New(error_str,
-                                                      Report::kBailout,
-                                                      Heap::kOld);
+  *background_compilation_error_ =
+      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
 
   // Some thread fields need to be reinitialized as null constants have not been
   // initialized until now.
   Thread* thr = Thread::Current();
   ASSERT(thr != NULL);
   thr->clear_sticky_error();
   thr->clear_pending_functions();
 
   ASSERT(!null_object_->IsSmi());
   ASSERT(!null_array_->IsSmi());
@@ skipping 39 matching lines @@
   ASSERT(background_compilation_error_->IsLanguageError());
   ASSERT(!vm_isolate_snapshot_object_table_->IsSmi());
   ASSERT(vm_isolate_snapshot_object_table_->IsArray());
 }
 
 
 // An object visitor which will mark all visited objects. This is used to
 // premark all objects in the vm_isolate_ heap.
 class PremarkingVisitor : public ObjectVisitor {
  public:
-  PremarkingVisitor() { }
+  PremarkingVisitor() {}
 
   void VisitObject(RawObject* obj) {
     // Free list elements should never be marked.
     ASSERT(!obj->IsMarked());
     // No forwarding corpses in the VM isolate.
     ASSERT(!obj->IsForwardingCorpse());
     if (!obj->IsFreeListElement()) {
       ASSERT(obj->IsVMHeapObject());
       obj->SetMarkBitUnsynchronized();
     }
   }
 };
 
 
 #define SET_CLASS_NAME(class_name, name)                                       \
   cls = class_name##_class();                                                  \
-  cls.set_name(Symbols::name());                                               \
+  cls.set_name(Symbols::name());
 
 void Object::FinalizeVMIsolate(Isolate* isolate) {
   // Should only be run by the vm isolate.
   ASSERT(isolate == Dart::vm_isolate());
 
   // Allocate the parameter arrays for method extractor types and names.
   *extractor_parameter_types_ = Array::New(1, Heap::kOld);
   extractor_parameter_types_->SetAt(0, Object::dynamic_type());
   *extractor_parameter_names_ = Array::New(1, Heap::kOld);
   extractor_parameter_names_->SetAt(0, Symbols::This());
@@ skipping 91 matching lines @@
       // Update the leftover space as a TypedDataInt8Array object.
       RawTypedData* raw =
           reinterpret_cast<RawTypedData*>(RawObject::FromAddr(addr));
       uword new_tags = RawObject::ClassIdTag::update(kTypedDataInt8ArrayCid, 0);
       new_tags = RawObject::SizeTag::update(leftover_size, new_tags);
       uword tags = raw->ptr()->tags_;
       uword old_tags;
       // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.
       do {
         old_tags = tags;
-        tags = AtomicOperations::CompareAndSwapWord(
-            &raw->ptr()->tags_, old_tags, new_tags);
+        tags = AtomicOperations::CompareAndSwapWord(&raw->ptr()->tags_,
+                                                    old_tags, new_tags);
       } while (tags != old_tags);
 
       intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
       ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
       raw->StoreSmi(&(raw->ptr()->length_), Smi::New(leftover_len));
     } else {
       // Update the leftover space as a basic object.
       ASSERT(leftover_size == Object::InstanceSize());
       RawObject* raw = reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
       uword new_tags = RawObject::ClassIdTag::update(kInstanceCid, 0);
       new_tags = RawObject::SizeTag::update(leftover_size, new_tags);
       uword tags = raw->ptr()->tags_;
       uword old_tags;
       // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.
       do {
         old_tags = tags;
-        tags = AtomicOperations::CompareAndSwapWord(
-            &raw->ptr()->tags_, old_tags, new_tags);
+        tags = AtomicOperations::CompareAndSwapWord(&raw->ptr()->tags_,
+                                                    old_tags, new_tags);
       } while (tags != old_tags);
     }
   }
 }
 
 
 void Object::VerifyBuiltinVtables() {
 #if defined(DEBUG)
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
@@ skipping 29 matching lines @@
   str = lib.PrivateName(public_class_name);
   cls.set_name(str);
   lib.AddClass(cls);
 }
 
 
 RawError* Object::Init(Isolate* isolate) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(isolate == thread->isolate());
-NOT_IN_PRODUCT(
-  TimelineDurationScope tds(thread,
-                            Timeline::GetIsolateStream(),
-                            "Object::Init");
-)
+  NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
+                                           "Object::Init"));
 
 #if defined(DART_NO_SNAPSHOT)
   // Object::Init version when we are running in a version of dart that does
   // not have a full snapshot linked in.
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle(zone);
   Type& type = Type::Handle(zone);
   Array& array = Array::Handle(zone);
   Library& lib = Library::Handle(zone);
@@ skipping 14 matching lines @@
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
   cls.set_type_arguments_field_offset(
       GrowableObjectArray::type_arguments_offset());
   cls.set_num_type_arguments(1);
 
   // Initialize hash set for canonical_type_.
   const intptr_t kInitialCanonicalTypeSize = 16;
-  array = HashTables::New<CanonicalTypeSet>(
-      kInitialCanonicalTypeSize, Heap::kOld);
+  array =
+      HashTables::New<CanonicalTypeSet>(kInitialCanonicalTypeSize, Heap::kOld);
   object_store->set_canonical_types(array);
 
   // Initialize hash set for canonical_type_arguments_.
   const intptr_t kInitialCanonicalTypeArgumentsSize = 4;
   array = HashTables::New<CanonicalTypeArgumentsSet>(
       kInitialCanonicalTypeArgumentsSize, Heap::kOld);
   object_store->set_canonical_type_arguments(array);
 
   // Setup type class early in the process.
   const Class& type_cls = Class::Handle(zone, Class::New<Type>());
   const Class& type_ref_cls = Class::Handle(zone, Class::New<TypeRef>());
-  const Class& type_parameter_cls = Class::Handle(zone,
-                                                  Class::New<TypeParameter>());
-  const Class& bounded_type_cls = Class::Handle(zone,
-                                                Class::New<BoundedType>());
-  const Class& mixin_app_type_cls = Class::Handle(zone,
-                                                  Class::New<MixinAppType>());
-  const Class& library_prefix_cls = Class::Handle(zone,
-                                                  Class::New<LibraryPrefix>());
+  const Class& type_parameter_cls =
+      Class::Handle(zone, Class::New<TypeParameter>());
+  const Class& bounded_type_cls =
+      Class::Handle(zone, Class::New<BoundedType>());
+  const Class& mixin_app_type_cls =
+      Class::Handle(zone, Class::New<MixinAppType>());
+  const Class& library_prefix_cls =
+      Class::Handle(zone, Class::New<LibraryPrefix>());
 
   // Pre-allocate the OneByteString class needed by the symbol table.
   cls = Class::NewStringClass(kOneByteStringCid);
   object_store->set_one_byte_string_class(cls);
 
   // Pre-allocate the TwoByteString class needed by the symbol table.
   cls = Class::NewStringClass(kTwoByteStringCid);
   object_store->set_two_byte_string_class(cls);
 
   // Setup the symbol table for the symbols created in the isolate.
   Symbols::SetupSymbolTable(isolate);
 
   // Set up the libraries array before initializing the core library.
-  const GrowableObjectArray& libraries = GrowableObjectArray::Handle(
-      zone, GrowableObjectArray::New(Heap::kOld));
+  const GrowableObjectArray& libraries =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New(Heap::kOld));
   object_store->set_libraries(libraries);
 
   // Pre-register the core library.
   Library::InitCoreLibrary(isolate);
 
   // Basic infrastructure has been setup, initialize the class dictionary.
   const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
 
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   object_store->set_pending_classes(pending_classes);
 
   Context& context = Context::Handle(zone, Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   String& name = String::Handle(zone);
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_List(), core_lib);
   pending_classes.Add(cls);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   // Warning: class _List has not been patched yet. Its declared number of type
   // parameters is still 0. It will become 1 after patching. The array type
   // allocated below represents the raw type _List and not _List<E> as we
   // could expect. Use with caution.
   type ^= Type::New(Object::Handle(zone, cls.raw()),
-                    TypeArguments::Handle(zone),
-                    TokenPosition::kNoSource);
+                    TypeArguments::Handle(zone), TokenPosition::kNoSource);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_GrowableList(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
@@ skipping 17 matching lines @@
   RegisterPrivateClass(cls, Symbols::ExternalOneByteString(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalTwoByteString(), core_lib);
   pending_classes.Add(cls);
 
   // Pre-register the isolate library so the native class implementations
   // can be hooked up before compiling it.
-  Library& isolate_lib =
-      Library::Handle(zone, Library::LookupLibrary(thread,
-                                                   Symbols::DartIsolate()));
+  Library& isolate_lib = Library::Handle(
+      zone, Library::LookupLibrary(thread, Symbols::DartIsolate()));
   if (isolate_lib.IsNull()) {
     isolate_lib = Library::NewLibraryHelper(Symbols::DartIsolate(), true);
     isolate_lib.SetLoadRequested();
     isolate_lib.Register(thread);
     object_store->set_bootstrap_library(ObjectStore::kIsolate, isolate_lib);
   }
   ASSERT(!isolate_lib.IsNull());
   ASSERT(isolate_lib.raw() == Library::IsolateLibrary());
 
   cls = Class::New<Capability>();
   RegisterPrivateClass(cls, Symbols::_CapabilityImpl(), isolate_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<ReceivePort>();
   RegisterPrivateClass(cls, Symbols::_RawReceivePortImpl(), isolate_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<SendPort>();
   RegisterPrivateClass(cls, Symbols::_SendPortImpl(), isolate_lib);
   pending_classes.Add(cls);
 
-  const Class& stacktrace_cls = Class::Handle(zone,
-                                              Class::New<Stacktrace>());
+  const Class& stacktrace_cls = Class::Handle(zone, Class::New<Stacktrace>());
   RegisterPrivateClass(stacktrace_cls, Symbols::_StackTrace(), core_lib);
   pending_classes.Add(stacktrace_cls);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<RegExp>();
   RegisterPrivateClass(cls, Symbols::_RegExp(), core_lib);
   pending_classes.Add(cls);
 
   // Initialize the base interfaces used by the core VM classes.
 
@@ skipping 75 matching lines @@
   cls.set_num_type_arguments(0);  // Although a closure has type_arguments_.
   cls.set_num_own_type_arguments(0);
   RegisterPrivateClass(cls, Symbols::_Closure(), core_lib);
   pending_classes.Add(cls);
   object_store->set_closure_class(cls);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
-  // Pre-register the mirrors library so we can place the vm class
-  // MirrorReference there rather than the core library.
-NOT_IN_PRODUCT(
+// Pre-register the mirrors library so we can place the vm class
+// MirrorReference there rather than the core library.
+#if !defined(PRODUCT)
   lib = Library::LookupLibrary(thread, Symbols::DartMirrors());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartMirrors(), true);
     lib.SetLoadRequested();
     lib.Register(thread);
     object_store->set_bootstrap_library(ObjectStore::kMirrors, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::MirrorsLibrary());
 
   cls = Class::New<MirrorReference>();
   RegisterPrivateClass(cls, Symbols::_MirrorReference(), lib);
-)
+#endif  // !defined(PRODUCT)
 
   // Pre-register the collection library so we can place the vm class
   // LinkedHashMap there rather than the core library.
   lib = Library::LookupLibrary(thread, Symbols::DartCollection());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartCollection(), true);
     lib.SetLoadRequested();
     lib.Register(thread);
     object_store->set_bootstrap_library(ObjectStore::kCollection, lib);
   }
@@ skipping 36 matching lines @@
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
     lib.SetLoadRequested();
     lib.Register(thread);
     object_store->set_bootstrap_library(ObjectStore::kTypedData, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##ArrayCid);                 \
-  RegisterClass(cls, Symbols::clazz##List(), lib);                             \
+  RegisterClass(cls, Symbols::clazz##List(), lib);
 
   DART_CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);              \
   RegisterPrivateClass(cls, Symbols::_##clazz##View(), lib);                   \
-  pending_classes.Add(cls);                                                    \
+  pending_classes.Add(cls);
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
   RegisterPrivateClass(cls, Symbols::_ByteDataView(), lib);
   pending_classes.Add(cls);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
-  RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
+  RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);
 
   cls = Class::New<Instance>(kByteBufferCid);
   cls.set_instance_size(0);
   cls.set_next_field_offset(-kWordSize);
   RegisterClass(cls, Symbols::ByteBuffer(), lib);
   pending_classes.Add(cls);
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
   // Register Float32x4 and Int32x4 in the object store.
@@ skipping 124 matching lines @@
   ASSERT(!cls.IsNull());
   Field& field = Field::Handle(zone);
   Smi& value = Smi::Handle(zone);
   String& field_name = String::Handle(zone);
 
 #define CLASS_LIST_WITH_NULL(V)                                                \
   V(Null)                                                                      \
   CLASS_LIST_NO_OBJECT(V)
 
 #define ADD_SET_FIELD(clazz)                                                   \
-  field_name = Symbols::New(thread, "cid"#clazz);                              \
-  field = Field::New(field_name, true, false, true, false, cls,                \
-      Type::Handle(Type::IntType()), TokenPosition::kMinSource);               \
+  field_name = Symbols::New(thread, "cid" #clazz);                             \
+  field =                                                                      \
+      Field::New(field_name, true, false, true, false, cls,                    \
+                 Type::Handle(Type::IntType()), TokenPosition::kMinSource);    \
   value = Smi::New(k##clazz##Cid);                                             \
   field.SetStaticValue(value, true);                                           \
-  cls.AddField(field);                                                         \
+  cls.AddField(field);
 
   CLASS_LIST_WITH_NULL(ADD_SET_FIELD)
 #undef ADD_SET_FIELD
 
   isolate->object_store()->InitKnownObjects();
 
   return Error::null();
 #else  // defined(DART_NO_SNAPSHOT).
   // Object::Init version when we are running in a version of dart that has
   // a full snapshot linked in and an isolate is initialized using the full
@@ skipping 98 matching lines @@
   cls = Class::New<Stacktrace>();
   cls = Class::New<RegExp>();
   cls = Class::New<Number>();
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
 
   cls = Class::New<MirrorReference>();
   cls = Class::New<UserTag>();
 
-  const Context& context = Context::Handle(zone,
-                                           Context::New(0, Heap::kOld));
+  const Context& context = Context::Handle(zone, Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
 #endif  // defined(DART_NO_SNAPSHOT).
 
   return Error::null();
 }
 
 
 #if defined(DEBUG)
-bool Object:: InVMHeap() const {
+bool Object::InVMHeap() const {
   if (FLAG_verify_handles && raw()->IsVMHeapObject()) {
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(vm_isolate_heap->Contains(RawObject::ToAddr(raw())));
   }
   return raw()->IsVMHeapObject();
 }
 #endif  // DEBUG
 
 
 void Object::Print() const {
   THR_Print("%s\n", ToCString());
 }
 
 
 RawString* Object::DictionaryName() const {
   return String::null();
 }
 
 
 void Object::InitializeObject(uword address,
                               intptr_t class_id,
                               intptr_t size,
                               bool is_vm_object) {
   uword initial_value = (class_id == kInstructionsCid)
-      ? Assembler::GetBreakInstructionFiller() : reinterpret_cast<uword>(null_);
+                            ? Assembler::GetBreakInstructionFiller()
+                            : reinterpret_cast<uword>(null_);
   uword cur = address;
   uword end = address + size;
   while (cur < end) {
     *reinterpret_cast<uword*>(cur) = initial_value;
     cur += kWordSize;
   }
   uword tags = 0;
   ASSERT(class_id != kIllegalCid);
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
@@ skipping 20 matching lines @@
       Heap* isolate_heap = isolate->heap();
       Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
       ASSERT(isolate_heap->Contains(RawObject::ToAddr(raw_)) ||
              vm_isolate_heap->Contains(RawObject::ToAddr(raw_)));
     }
   }
 #endif
 }
 
 
-RawObject* Object::Allocate(intptr_t cls_id,
-                            intptr_t size,
-                            Heap::Space space) {
+RawObject* Object::Allocate(intptr_t cls_id, intptr_t size, Heap::Space space) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   // New space allocation allowed only in mutator thread (Dart thread);
   ASSERT(thread->IsMutatorThread() || (space != Heap::kNew));
   ASSERT(thread->no_callback_scope_depth() == 0);
   Heap* heap = isolate->heap();
 
   uword address = heap->Allocate(size, space);
   if (address == 0) {
@@ skipping 19 matching lines @@
   NoSafepointScope no_safepoint;
   InitializeObject(address, cls_id, size, (isolate == Dart::vm_isolate()));
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   ASSERT(cls_id == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
   return raw_obj;
 }
 
 
 class StoreBufferUpdateVisitor : public ObjectPointerVisitor {
  public:
-  explicit StoreBufferUpdateVisitor(Thread* thread, RawObject* obj) :
-      ObjectPointerVisitor(thread->isolate()), thread_(thread), old_obj_(obj) {
+  explicit StoreBufferUpdateVisitor(Thread* thread, RawObject* obj)
+      : ObjectPointerVisitor(thread->isolate()),
+        thread_(thread),
+        old_obj_(obj) {
     ASSERT(old_obj_->IsOldObject());
   }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** curr = first; curr <= last; ++curr) {
       RawObject* raw_obj = *curr;
       if (raw_obj->IsHeapObject() && raw_obj->IsNewObject()) {
         old_obj_->SetRememberedBit();
         thread_->StoreBufferAddObject(old_obj_);
         // Remembered this object. There is no need to continue searching.
@@ skipping 13 matching lines @@
 bool Object::IsReadOnlyHandle() const {
   return Dart::IsReadOnlyHandle(reinterpret_cast<uword>(this));
 }
 
 
 bool Object::IsNotTemporaryScopedHandle() const {
   return (IsZoneHandle() || IsReadOnlyHandle());
 }
 
 
-
 RawObject* Object::Clone(const Object& orig, Heap::Space space) {
   const Class& cls = Class::Handle(orig.clazz());
   intptr_t size = orig.raw()->Size();
   RawObject* raw_clone = Object::Allocate(cls.id(), size, space);
   NoSafepointScope no_safepoint;
   // TODO(koda): This will trip when we start allocating black.
   // Revisit code below at that point, to account for the new write barrier.
   ASSERT(!raw_clone->IsMarked());
   // Copy the body of the original into the clone.
   uword orig_addr = RawObject::ToAddr(orig.raw());
@@ skipping 21 matching lines @@
   return raw_ptr()->name_;
 }
 
 
 RawString* Class::ScrubbedName() const {
   return String::ScrubName(String::Handle(Name()));
 }
 
 
 RawString* Class::UserVisibleName() const {
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   ASSERT(raw_ptr()->user_name_ != String::null());
   return raw_ptr()->user_name_;
-)
+#endif                               // !defined(PRODUCT)
   return GenerateUserVisibleName();  // No caching in PRODUCT, regenerate.
 }
 
 
 bool Class::IsInFullSnapshot() const {
   NoSafepointScope no_safepoint;
   return raw_ptr()->library_->ptr()->is_in_fullsnapshot_;
 }
 
 
 RawAbstractType* Class::RareType() const {
   const Type& type = Type::Handle(Type::New(
-      *this,
-      Object::null_type_arguments(),
-      TokenPosition::kNoSource));
-  return ClassFinalizer::FinalizeType(*this,
-                                      type,
+      *this, Object::null_type_arguments(), TokenPosition::kNoSource));
+  return ClassFinalizer::FinalizeType(*this, type,
                                       ClassFinalizer::kCanonicalize);
 }
 
 
 RawAbstractType* Class::DeclarationType() const {
   const TypeArguments& args = TypeArguments::Handle(type_parameters());
-  const Type& type = Type::Handle(Type::New(
-      *this,
-      args,
-      TokenPosition::kNoSource));
-  return ClassFinalizer::FinalizeType(*this,
-                                      type,
+  const Type& type =
+      Type::Handle(Type::New(*this, args, TokenPosition::kNoSource));
+  return ClassFinalizer::FinalizeType(*this, type,
                                       ClassFinalizer::kCanonicalize);
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(Class::kClassId,
-                                      Class::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(Class::kClassId, Class::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::NextFieldOffset());
   COMPILE_ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
@@ skipping 10 matching lines @@
   result.set_num_type_arguments(0);
   result.set_num_own_type_arguments(0);
   result.set_num_native_fields(0);
   result.set_token_pos(TokenPosition::kNoSource);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
-
 static void ReportTooManyTypeArguments(const Class& cls) {
-  Report::MessageF(Report::kError,
-                   Script::Handle(cls.script()),
-                   cls.token_pos(),
-                   Report::AtLocation,
+  Report::MessageF(Report::kError, Script::Handle(cls.script()),
+                   cls.token_pos(), Report::AtLocation,
                    "too many type parameters declared in class '%s' or in its "
                    "super classes",
                    String::Handle(cls.Name()).ToCString());
   UNREACHABLE();
 }
 
 
 void Class::set_num_type_arguments(intptr_t value) const {
   if (!Utils::IsInt(16, value)) {
     ReportTooManyTypeArguments(*this);
@@ skipping 69 matching lines @@
       : name_(name), tmp_string_(tmp_string) {}
   bool Matches(const Function& function) const {
     if (name_.IsSymbol()) {
       return name_.raw() == function.name();
     } else {
       *tmp_string_ = function.name();
       return name_.Equals(*tmp_string_);
     }
   }
   intptr_t Hash() const { return name_.Hash(); }
+
  private:
   const String& name_;
   String* tmp_string_;
 };
 
 
 // Traits for looking up Functions by name.
 class ClassFunctionsTraits {
  public:
   static const char* Name() { return "ClassFunctionsTraits"; }
   static bool ReportStats() { return false; }
 
   // Called when growing the table.
   static bool IsMatch(const Object& a, const Object& b) {
     ASSERT(a.IsFunction() && b.IsFunction());
     // Function objects are always canonical.
     return a.raw() == b.raw();
   }
   static bool IsMatch(const FunctionName& name, const Object& obj) {
     return name.Matches(Function::Cast(obj));
   }
   static uword Hash(const Object& key) {
     return String::HashRawSymbol(Function::Cast(key).name());
   }
-  static uword Hash(const FunctionName& name) {
-    return name.Hash();
-  }
+  static uword Hash(const FunctionName& name) { return name.Hash(); }
 };
 typedef UnorderedHashSet<ClassFunctionsTraits> ClassFunctionsSet;
 
 
 void Class::SetFunctions(const Array& value) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->functions_, value.raw());
   const intptr_t len = value.Length();
   if (len >= kFunctionLookupHashTreshold) {
@@ skipping 99 matching lines @@
     }
     if (needle.raw() == implicit_closure.raw()) {
       return i;
     }
   }
   // No function found.
   return -1;
 }
 
 
-
 intptr_t Class::FindInvocationDispatcherFunctionIndex(
     const Function& needle) const {
   Thread* thread = Thread::Current();
   if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(thread);
   REUSABLE_OBJECT_HANDLESCOPE(thread);
   Array& funcs = thread->ArrayHandle();
   Object& object = thread->ObjectHandle();
@@ skipping 50 matching lines @@
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
 intptr_t Class::NumTypeParameters(Thread* thread) const {
   if (IsMixinApplication() && !is_mixin_type_applied()) {
     ClassFinalizer::ApplyMixinType(*this);
   }
   if (type_parameters() == TypeArguments::null()) {
     const intptr_t cid = id();
-    if ((cid == kArrayCid) ||
-        (cid == kImmutableArrayCid) ||
+    if ((cid == kArrayCid) || (cid == kImmutableArrayCid) ||
         (cid == kGrowableObjectArrayCid)) {
       return 1;  // List's type parameter may not have been parsed yet.
     }
     return 0;
   }
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   type_params = type_parameters();
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
   // Return cached value if already calculated.
   if (num_own_type_arguments() != kUnknownNumTypeArguments) {
     return num_own_type_arguments();
   }
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   const intptr_t num_type_params = NumTypeParameters();
-  if (!FLAG_overlap_type_arguments ||
-      (num_type_params == 0) ||
+  if (!FLAG_overlap_type_arguments || (num_type_params == 0) ||
       (super_type() == AbstractType::null()) ||
       (super_type() == isolate->object_store()->object_type())) {
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   ASSERT(!IsMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(zone, super_type());
   const TypeArguments& sup_type_args =
       TypeArguments::Handle(zone, sup_type.arguments());
   if (sup_type_args.IsNull()) {
@@ skipping 17 matching lines @@
   // type parameters of this class with a suffix of the vector consisting of the
   // type arguments of the super type of this class.
   // The number of own type arguments of this class is the number of its type
   // parameters minus the number of type arguments in the overlap.
   // Attempt to overlap the whole vector of type parameters; reduce the size
   // of the vector (keeping the first type parameter) until it fits or until
   // its size is zero.
   TypeParameter& type_param = TypeParameter::Handle(zone);
   AbstractType& sup_type_arg = AbstractType::Handle(zone);
   for (intptr_t num_overlapping_type_args =
-           (num_type_params < num_sup_type_args) ?
-               num_type_params : num_sup_type_args;
+           (num_type_params < num_sup_type_args) ? num_type_params
+                                                 : num_sup_type_args;
        num_overlapping_type_args > 0; num_overlapping_type_args--) {
     intptr_t i = 0;
     for (; i < num_overlapping_type_args; i++) {
       type_param ^= type_params.TypeAt(i);
-      sup_type_arg = sup_type_args.TypeAt(
-          num_sup_type_args - num_overlapping_type_args + i);
+      sup_type_arg = sup_type_args.TypeAt(num_sup_type_args -
+                                          num_overlapping_type_args + i);
       // BoundedType can nest in case the finalized super type has bounded type
       // arguments that overlap multiple times in its own super class chain.
       while (sup_type_arg.IsBoundedType()) {
         sup_type_arg = BoundedType::Cast(sup_type_arg).type();
       }
       if (!type_param.Equals(sup_type_arg)) break;
     }
     if (i == num_overlapping_type_args) {
       // Overlap found.
       set_num_own_type_arguments(num_type_params - num_overlapping_type_args);
@@ skipping 46 matching lines @@
 RawClass* Class::SuperClass() const {
   if (super_type() == AbstractType::null()) {
     return Class::null();
   }
   const AbstractType& sup_type = AbstractType::Handle(super_type());
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const AbstractType& value) const {
-  ASSERT(value.IsNull() ||
-         (value.IsType() && !value.IsDynamicType()) ||
+  ASSERT(value.IsNull() || (value.IsType() && !value.IsDynamicType()) ||
          value.IsMixinAppType());
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 RawTypeParameter* Class::LookupTypeParameter(const String& type_name) const {
   ASSERT(!type_name.IsNull());
   Thread* thread = Thread::Current();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   REUSABLE_TYPE_PARAMETER_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
-  TypeParameter&  type_param = thread->TypeParameterHandle();
+  TypeParameter& type_param = thread->TypeParameterHandle();
   String& type_param_name = thread->StringHandle();
 
   type_params ^= type_parameters();
   if (!type_params.IsNull()) {
     const intptr_t num_type_params = type_params.Length();
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type_param_name = type_param.name();
       if (type_param_name.Equals(type_name)) {
         return type_param.raw();
@@ skipping 50 matching lines @@
   }
   set_instance_size(RoundedAllocationSize(offset));
   set_next_field_offset(offset);
 }
 
 
 RawFunction* Class::GetInvocationDispatcher(const String& target_name,
                                             const Array& args_desc,
                                             RawFunction::Kind kind,
                                             bool create_if_absent) const {
-  enum {
-    kNameIndex = 0,
-    kArgsDescIndex,
-    kFunctionIndex,
-    kEntrySize
-  };
+  enum { kNameIndex = 0, kArgsDescIndex, kFunctionIndex, kEntrySize };
 
   ASSERT(kind == RawFunction::kNoSuchMethodDispatcher ||
          kind == RawFunction::kInvokeFieldDispatcher);
   Function& dispatcher = Function::Handle();
   Array& cache = Array::Handle(invocation_dispatcher_cache());
   ASSERT(!cache.IsNull());
   String& name = String::Handle();
   Array& desc = Array::Handle();
   intptr_t i = 0;
   for (; i < cache.Length(); i += kEntrySize) {
     name ^= cache.At(i + kNameIndex);
     if (name.IsNull()) break;  // Reached last entry.
     if (!name.Equals(target_name)) continue;
     desc ^= cache.At(i + kArgsDescIndex);
     if (desc.raw() != args_desc.raw()) continue;
     dispatcher ^= cache.At(i + kFunctionIndex);
     if (dispatcher.kind() == kind) {
       // Found match.
       ASSERT(dispatcher.IsFunction());
       break;
     }
   }
 
   if (dispatcher.IsNull() && create_if_absent) {
     if (i == cache.Length()) {
       // Allocate new larger cache.
       intptr_t new_len = (cache.Length() == 0)
-          ? static_cast<intptr_t>(kEntrySize)
-          : cache.Length() * 2;
+                             ? static_cast<intptr_t>(kEntrySize)
+                             : cache.Length() * 2;
       cache ^= Array::Grow(cache, new_len);
       set_invocation_dispatcher_cache(cache);
     }
     dispatcher ^= CreateInvocationDispatcher(target_name, args_desc, kind);
     cache.SetAt(i + kNameIndex, target_name);
     cache.SetAt(i + kArgsDescIndex, args_desc);
     cache.SetAt(i + kFunctionIndex, dispatcher);
   }
   return dispatcher.raw();
 }
 
 
 RawFunction* Class::CreateInvocationDispatcher(const String& target_name,
                                                const Array& args_desc,
                                                RawFunction::Kind kind) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  Function& invocation = Function::Handle(zone,
-      Function::New(String::Handle(zone, Symbols::New(thread, target_name)),
-                    kind,
-                    false,  // Not static.
-                    false,  // Not const.
-                    false,  // Not abstract.
-                    false,  // Not external.
-                    false,  // Not native.
-                    *this,
-                    TokenPosition::kMinSource));
+  Function& invocation = Function::Handle(
+      zone, Function::New(
+                String::Handle(zone, Symbols::New(thread, target_name)), kind,
+                false,  // Not static.
+                false,  // Not const.
+                false,  // Not abstract.
+                false,  // Not external.
+                false,  // Not native.
+                *this, TokenPosition::kMinSource));
   ArgumentsDescriptor desc(args_desc);
   invocation.set_num_fixed_parameters(desc.PositionalCount());
   invocation.SetNumOptionalParameters(desc.NamedCount(),
                                       false);  // Not positional.
-  invocation.set_parameter_types(Array::Handle(zone, Array::New(desc.Count(),
-                                                                Heap::kOld)));
-  invocation.set_parameter_names(Array::Handle(zone, Array::New(desc.Count(),
-                                                                Heap::kOld)));
+  invocation.set_parameter_types(
+      Array::Handle(zone, Array::New(desc.Count(), Heap::kOld)));
+  invocation.set_parameter_names(
+      Array::Handle(zone, Array::New(desc.Count(), Heap::kOld)));
   // Receiver.
   invocation.SetParameterTypeAt(0, Object::dynamic_type());
   invocation.SetParameterNameAt(0, Symbols::This());
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); i++) {
     invocation.SetParameterTypeAt(i, Object::dynamic_type());
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
-    invocation.SetParameterNameAt(i, String::Handle(zone,
-        Symbols::New(thread, name)));
+    invocation.SetParameterNameAt(
+        i, String::Handle(zone, Symbols::New(thread, name)));
   }
 
   // Named parameters.
   for (; i < desc.Count(); i++) {
     invocation.SetParameterTypeAt(i, Object::dynamic_type());
     intptr_t index = i - desc.PositionalCount();
     invocation.SetParameterNameAt(i, String::Handle(zone, desc.NameAt(index)));
   }
   invocation.set_result_type(Object::dynamic_type());
   invocation.set_is_debuggable(false);
@@ skipping 11 matching lines @@
 // is created and injected as a getter (under the name get:M) into the class
 // owning method M.
 RawFunction* Function::CreateMethodExtractor(const String& getter_name) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(Field::IsGetterName(getter_name));
   const Function& closure_function =
       Function::Handle(zone, ImplicitClosureFunction());
 
   const Class& owner = Class::Handle(zone, closure_function.Owner());
-  Function& extractor = Function::Handle(zone,
-    Function::New(String::Handle(zone, Symbols::New(thread, getter_name)),
-                  RawFunction::kMethodExtractor,
-                  false,  // Not static.
-                  false,  // Not const.
-                  false,  // Not abstract.
-                  false,  // Not external.
-                  false,  // Not native.
-                  owner,
-                  TokenPosition::kMethodExtractor));
+  Function& extractor = Function::Handle(
+      zone,
+      Function::New(String::Handle(zone, Symbols::New(thread, getter_name)),
+                    RawFunction::kMethodExtractor,
+                    false,  // Not static.
+                    false,  // Not const.
+                    false,  // Not abstract.
+                    false,  // Not external.
+                    false,  // Not native.
+                    owner, TokenPosition::kMethodExtractor));
 
   // Initialize signature: receiver is a single fixed parameter.
   const intptr_t kNumParameters = 1;
   extractor.set_num_fixed_parameters(kNumParameters);
   extractor.SetNumOptionalParameters(0, 0);
   extractor.set_parameter_types(Object::extractor_parameter_types());
   extractor.set_parameter_names(Object::extractor_parameter_names());
   extractor.set_result_type(Object::dynamic_type());
   extractor.set_kernel_function(kernel_function());
 
@@ skipping 41 matching lines @@
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
   }
   set_is_finalized();
 }
 
 
 class CHACodeArray : public WeakCodeReferences {
  public:
   explicit CHACodeArray(const Class& cls)
-      : WeakCodeReferences(Array::Handle(cls.dependent_code())), cls_(cls) {
-  }
+      : WeakCodeReferences(Array::Handle(cls.dependent_code())), cls_(cls) {}
 
   virtual void UpdateArrayTo(const Array& value) {
     // TODO(fschneider): Fails for classes in the VM isolate.
     cls_.set_dependent_code(value);
   }
 
   virtual void ReportDeoptimization(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       Function& function = Function::Handle(code.function());
       THR_Print("Deoptimizing %s because CHA optimized (%s).\n",
-          function.ToFullyQualifiedCString(),
-          cls_.ToCString());
+                function.ToFullyQualifiedCString(), cls_.ToCString());
     }
   }
 
   virtual void ReportSwitchingCode(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       Function& function = Function::Handle(code.function());
-      THR_Print("Switching %s to unoptimized code because CHA invalid"
-                " (%s)\n",
-                function.ToFullyQualifiedCString(),
-                cls_.ToCString());
+      THR_Print(
+          "Switching %s to unoptimized code because CHA invalid"
+          " (%s)\n",
+          function.ToFullyQualifiedCString(), cls_.ToCString());
     }
   }
 
  private:
   const Class& cls_;
   DISALLOW_COPY_AND_ASSIGN(CHACodeArray);
 };
 
 
 #if defined(DEBUG)
 static bool IsMutatorOrAtSafepoint() {
   Thread* thread = Thread::Current();
   return thread->IsMutatorThread() || thread->IsAtSafepoint();
 }
 #endif
 
 
 void Class::RegisterCHACode(const Code& code) {
   if (FLAG_trace_cha) {
     THR_Print("RegisterCHACode '%s' depends on class '%s'\n",
-        Function::Handle(code.function()).ToQualifiedCString(), ToCString());
+              Function::Handle(code.function()).ToQualifiedCString(),
+              ToCString());
   }
   DEBUG_ASSERT(IsMutatorOrAtSafepoint());
   ASSERT(code.is_optimized());
   CHACodeArray a(*this);
   a.Register(code);
 }
 
 
 void Class::DisableCHAOptimizedCode(const Class& subclass) {
   ASSERT(Thread::Current()->IsMutatorThread());
@@ skipping 35 matching lines @@
 }
 
 
 bool Class::ValidatePostFinalizePatch(const Class& orig_class,
                                       Error* error) const {
   ASSERT(error != NULL);
   // Not allowed to add new fields in a post finalization patch.
   if (fields() != Object::empty_array().raw()) {
     *error = LanguageError::NewFormatted(
         *error,  // No previous error.
-        Script::Handle(script()),
-        token_pos(),
-        Report::AtLocation,
-        Report::kError,
-        Heap::kNew,
+        Script::Handle(script()), token_pos(), Report::AtLocation,
+        Report::kError, Heap::kNew,
         "new fields are not allowed for this patch");
     return false;
   }
   // There seem to be no functions, the patch is pointless.
   if (functions() == Object::empty_array().raw()) {
-    *error = LanguageError::NewFormatted(
-        *error,  // No previous error.
-        Script::Handle(script()),
-        token_pos(),
-        Report::AtLocation,
-        Report::kError,
-        Heap::kNew,
-        "no functions to patch");
+    *error = LanguageError::NewFormatted(*error,  // No previous error.
+                                         Script::Handle(script()), token_pos(),
+                                         Report::AtLocation, Report::kError,
+                                         Heap::kNew, "no functions to patch");
     return false;
   }
   // Iterate over all functions that will be patched and make sure
   // the original function was declared 'external' and has not executed
   // so far i.e no code has been generated for it.
   Thread* thread = Thread::Current();
   ASSERT(thread->IsMutatorThread());
   Zone* zone = thread->zone();
   const Array& funcs = Array::Handle(zone, functions());
   Function& func = Function::Handle(zone);
   Function& orig_func = Function::Handle(zone);
   String& name = String::Handle(zone);
   for (intptr_t i = 0; i < funcs.Length(); i++) {
     func ^= funcs.At(i);
     name ^= func.name();
     orig_func ^= orig_class.LookupFunctionAllowPrivate(name);
     if (!orig_func.IsNull()) {
       if (!orig_func.is_external() || orig_func.HasCode()) {
         // We can only patch external functions in a post finalized class.
         *error = LanguageError::NewFormatted(
             *error,  // No previous error.
-            Script::Handle(script()),
-            token_pos(),
-            Report::AtLocation,
-            Report::kError,
-            Heap::kNew,
-            !orig_func.is_external() ?
-            "'%s' is not external and therefore cannot be patched" :
-            "'%s' has already executed and therefore cannot be patched",
+            Script::Handle(script()), token_pos(), Report::AtLocation,
+            Report::kError, Heap::kNew,
+            !orig_func.is_external()
+                ? "'%s' is not external and therefore cannot be patched"
+                : "'%s' has already executed and therefore cannot be patched",
             name.ToCString());
         return false;
       }
     } else if (!Library::IsPrivate(name)) {
       // We can only have new private functions that are added.
       *error = LanguageError::NewFormatted(
           *error,  // No previous error.
-          Script::Handle(script()),
-          token_pos(),
-          Report::AtLocation,
-          Report::kError,
-          Heap::kNew,
+          Script::Handle(script()), token_pos(), Report::AtLocation,
+          Report::kError, Heap::kNew,
           "'%s' is not private and therefore cannot be patched",
           name.ToCString());
       return false;
     }
   }
   return true;
 }
 
 
 void Class::set_dependent_code(const Array& array) const {
@@ skipping 22 matching lines @@
   Function& orig_func = Function::Handle();
   // Lookup the original implicit constructor, if any.
   member_name = Name();
   member_name = String::Concat(member_name, Symbols::Dot());
   Function& orig_implicit_ctor = Function::Handle(LookupFunction(member_name));
   if (!orig_implicit_ctor.IsNull() &&
       !orig_implicit_ctor.IsImplicitConstructor()) {
     // Not an implicit constructor, but a user declared one.
     orig_implicit_ctor = Function::null();
   }
-  const GrowableObjectArray& new_functions = GrowableObjectArray::Handle(
-      GrowableObjectArray::New(orig_len));
+  const GrowableObjectArray& new_functions =
+      GrowableObjectArray::Handle(GrowableObjectArray::New(orig_len));
   for (intptr_t i = 0; i < orig_len; i++) {
     orig_func ^= orig_list.At(i);
     member_name ^= orig_func.name();
     func = patch.LookupFunction(member_name);
     if (func.IsNull()) {
       // Non-patched function is preserved, all patched functions are added in
       // the loop below.
       // However, an implicitly created constructor should not be preserved if
       // the patch provides a constructor or a factory. Wait for now.
       if (orig_func.raw() != orig_implicit_ctor.raw()) {
         new_functions.Add(orig_func);
       }
     } else if (func.UserVisibleSignature() !=
-               orig_func.UserVisibleSignature()
-               && !FLAG_ignore_patch_signature_mismatch) {
+                   orig_func.UserVisibleSignature() &&
+               !FLAG_ignore_patch_signature_mismatch) {
       // Compare user visible signatures to ignore different implicit parameters
       // when patching a constructor with a factory.
       *error = LanguageError::NewFormatted(
           *error,  // No previous error.
-          Script::Handle(patch.script()),
-          func.token_pos(),
-          Report::AtLocation,
-          Report::kError,
-          Heap::kNew,
-          "signature mismatch: '%s'", member_name.ToCString());
+          Script::Handle(patch.script()), func.token_pos(), Report::AtLocation,
+          Report::kError, Heap::kNew, "signature mismatch: '%s'",
+          member_name.ToCString());
       return false;
     }
   }
   for (intptr_t i = 0; i < patch_len; i++) {
     func ^= patch_list.At(i);
     if (func.IsGenerativeConstructor() || func.IsFactory()) {
       // Do not preserve the original implicit constructor, if any.
       orig_implicit_ctor = Function::null();
     }
     func.set_owner(patch_class);
@@ skipping 20 matching lines @@
     field ^= patch_list.At(i);
     field.set_owner(patch_class);
     member_name = field.name();
     // TODO(iposva): Verify non-public fields only.
 
     // Verify no duplicate additions.
     orig_field ^= LookupField(member_name);
     if (!orig_field.IsNull()) {
       *error = LanguageError::NewFormatted(
           *error,  // No previous error.
-          Script::Handle(patch.script()),
-          field.token_pos(),
-          Report::AtLocation,
-          Report::kError,
-          Heap::kNew,
-          "duplicate field: %s", member_name.ToCString());
+          Script::Handle(patch.script()), field.token_pos(), Report::AtLocation,
+          Report::kError, Heap::kNew, "duplicate field: %s",
+          member_name.ToCString());
       return false;
     }
     new_list.SetAt(i, field);
   }
   for (intptr_t i = 0; i < orig_len; i++) {
     field ^= orig_list.At(i);
     new_list.SetAt(patch_len + i, field);
   }
   SetFields(new_list);
 
@@ skipping 28 matching lines @@
 }
 
 
 static RawFunction* EvaluateHelper(const Class& cls,
                                    const String& expr,
                                    const Array& param_names,
                                    bool is_static) {
   const String& func_src =
       String::Handle(BuildClosureSource(param_names, expr));
   Script& script = Script::Handle();
-  script = Script::New(Symbols::EvalSourceUri(),
-                       func_src,
-                       RawScript::kEvaluateTag);
+  script =
+      Script::New(Symbols::EvalSourceUri(), func_src, RawScript::kEvaluateTag);
   // In order to tokenize the source, we need to get the key to mangle
   // private names from the library from which the class originates.
   const Library& lib = Library::Handle(cls.library());
   ASSERT(!lib.IsNull());
   const String& lib_key = String::Handle(lib.private_key());
   script.Tokenize(lib_key, false);
 
-  const Function& func = Function::Handle(
-       Function::NewEvalFunction(cls, script, is_static));
+  const Function& func =
+      Function::Handle(Function::NewEvalFunction(cls, script, is_static));
   func.set_result_type(Object::dynamic_type());
   const intptr_t num_implicit_params = is_static ? 0 : 1;
   func.set_num_fixed_parameters(num_implicit_params + param_names.Length());
   func.SetNumOptionalParameters(0, true);
   func.SetIsOptimizable(false);
   return func.raw();
 }
 
 
 RawObject* Class::Evaluate(const String& expr,
                            const Array& param_names,
                            const Array& param_values) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   if (id() < kInstanceCid) {
-    const Instance& exception = Instance::Handle(String::New(
-        "Cannot evaluate against a VM internal class"));
+    const Instance& exception = Instance::Handle(
+        String::New("Cannot evaluate against a VM internal class"));
     const Instance& stacktrace = Instance::Handle();
     return UnhandledException::New(exception, stacktrace);
   }
 
   const Function& eval_func =
       Function::Handle(EvaluateHelper(*this, expr, param_names, true));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, param_values));
   return result.raw();
 }
 
 
 // Ensure that top level parsing of the class has been done.
 RawError* Class::EnsureIsFinalized(Thread* thread) const {
   // Finalized classes have already been parsed.
   if (is_finalized()) {
     return Error::null();
   }
   if (Compiler::IsBackgroundCompilation()) {
     Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
-        "Class finalization while compiling");
+                                         "Class finalization while compiling");
   }
   ASSERT(thread->IsMutatorThread());
   ASSERT(thread != NULL);
-  const Error& error = Error::Handle(
-      thread->zone(), Compiler::CompileClass(*this));
+  const Error& error =
+      Error::Handle(thread->zone(), Compiler::CompileClass(*this));
   if (!error.IsNull()) {
     ASSERT(thread == Thread::Current());
     if (thread->long_jump_base() != NULL) {
       Report::LongJump(error);
       UNREACHABLE();
     }
   }
   return error.raw();
 }
 
@@ skipping 35 matching lines @@
   }
   SetFields(new_arr);
 }
 
 
 template <class FakeInstance>
 RawClass* Class::NewCommon(intptr_t index) {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(Class::kClassId,
-                                      Class::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(Class::kClassId, Class::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::NextFieldOffset());
   result.set_id(index);
   result.set_state_bits(0);
@@ skipping 109 matching lines @@
   result.set_next_field_offset(ExternalTypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(raw_ptr()->name_ == String::null());
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   if (raw_ptr()->user_name_ == String::null()) {
     // TODO(johnmccutchan): Eagerly set user name for VM isolate classes,
     // lazily set user name for the other classes.
     // Generate and set user_name.
     const String& user_name = String::Handle(GenerateUserVisibleName());
     set_user_name(user_name);
   }
-)
+#endif  // !defined(PRODUCT)
 }
 
 
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
 void Class::set_user_name(const String& value) const {
   StorePointer(&raw_ptr()->user_name_, value.raw());
 }
-)
+#endif  // !defined(PRODUCT)
 
 
 RawString* Class::GenerateUserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
     case kFloat32x4Cid:
       return Symbols::Float32x4().raw();
     case kInt32x4Cid:
@@ skipping 33 matching lines @@
       return Symbols::Float32x4List().raw();
     case kTypedDataFloat64x2ArrayCid:
     case kExternalTypedDataFloat64x2ArrayCid:
       return Symbols::Float64x2List().raw();
     case kTypedDataFloat32ArrayCid:
     case kExternalTypedDataFloat32ArrayCid:
       return Symbols::Float32List().raw();
     case kTypedDataFloat64ArrayCid:
     case kExternalTypedDataFloat64ArrayCid:
       return Symbols::Float64List().raw();
-NOT_IN_PRODUCT(
+
+#if !defined(PRODUCT)
     case kNullCid:
       return Symbols::Null().raw();
     case kDynamicCid:
       return Symbols::Dynamic().raw();
     case kVoidCid:
       return Symbols::Void().raw();
     case kClassCid:
       return Symbols::Class().raw();
     case kUnresolvedClassCid:
       return Symbols::UnresolvedClass().raw();
@@ skipping 66 matching lines @@
       return Symbols::Double().raw();
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kExternalOneByteStringCid:
     case kExternalTwoByteStringCid:
       return Symbols::_String().raw();
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
       return Symbols::List().raw();
-)
+#endif  // !defined(PRODUCT)
   }
   const String& name = String::Handle(Name());
   return String::ScrubName(name);
 }
 
 
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
@@ skipping 10 matching lines @@
     return token_pos();
   }
   Zone* zone = Thread::Current()->zone();
   const Script& scr = Script::Handle(zone, script());
   ASSERT(!scr.IsNull());
   const TokenStream& tkns = TokenStream::Handle(zone, scr.tokens());
   if (tkns.IsNull()) {
     ASSERT(Dart::snapshot_kind() == Snapshot::kAppNoJIT);
     return TokenPosition::kNoSource;
   }
-  TokenStream::Iterator tkit(zone,
-                             tkns,
-                             token_pos(),
+  TokenStream::Iterator tkit(zone, tkns, token_pos(),
                              TokenStream::Iterator::kNoNewlines);
   intptr_t level = 0;
   while (tkit.CurrentTokenKind() != Token::kEOS) {
     if (tkit.CurrentTokenKind() == Token::kLBRACE) {
       level++;
     } else if (tkit.CurrentTokenKind() == Token::kRBRACE) {
       if (--level == 0) {
         return tkit.CurrentPosition();
       }
     }
@@ skipping 60 matching lines @@
 }
 
 
 void Class::set_is_allocated(bool value) const {
   set_state_bits(IsAllocatedBit::update(value, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
-  set_state_bits(ClassFinalizedBits::update(RawClass::kFinalized,
-                                            raw_ptr()->state_bits_));
+  set_state_bits(
+      ClassFinalizedBits::update(RawClass::kFinalized, raw_ptr()->state_bits_));
 }
 
 
 void Class::SetRefinalizeAfterPatch() const {
   ASSERT(!IsTopLevel());
   set_state_bits(ClassFinalizedBits::update(RawClass::kRefinalizeAfterPatch,
                                             raw_ptr()->state_bits_));
   set_state_bits(TypeFinalizedBit::update(false, raw_ptr()->state_bits_));
 }
 
 
 void Class::ResetFinalization() const {
   ASSERT(IsTopLevel());
-  set_state_bits(ClassFinalizedBits::update(RawClass::kAllocated,
-                                            raw_ptr()->state_bits_));
+  set_state_bits(
+      ClassFinalizedBits::update(RawClass::kAllocated, raw_ptr()->state_bits_));
   set_state_bits(TypeFinalizedBit::update(false, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_prefinalized() const {
   ASSERT(!is_finalized());
   set_state_bits(ClassFinalizedBits::update(RawClass::kPreFinalized,
                                             raw_ptr()->state_bits_));
 }
 
@@ skipping 147 matching lines @@
     // is interpreted as the bottom type, a subtype of all types.
     // However, DynamicType is not more specific than any type.
     if (thsi.IsDynamicClass()) {
       return test_kind == Class::kIsSubtypeOf;
     }
     // Check for NullType, which is only a subtype of ObjectType, of
     // DynamicType, or of itself, and which is more specific than any type.
     if (thsi.IsNullClass()) {
       // We already checked for other.IsDynamicClass() above.
       return (test_kind == Class::kIsMoreSpecificThan) ||
-      other.IsObjectClass() || other.IsNullClass();
+             other.IsObjectClass() || other.IsNullClass();
     }
     // Check for ObjectType. Any type that is not NullType or DynamicType
     // (already checked above), is more specific than ObjectType.
     if (other.IsObjectClass()) {
       return true;
     }
     // Check for reflexivity.
     if (thsi.raw() == other.raw()) {
       const intptr_t num_type_params = thsi.NumTypeParameters();
       if (num_type_params == 0) {
         return true;
       }
       const intptr_t num_type_args = thsi.NumTypeArguments();
       const intptr_t from_index = num_type_args - num_type_params;
       // Since we do not truncate the type argument vector of a subclass (see
       // below), we only check a subvector of the proper length.
       // Check for covariance.
       if (other_type_arguments.IsNull() ||
           other_type_arguments.IsRaw(from_index, num_type_params)) {
         return true;
       }
       if (type_arguments.IsNull() ||
           type_arguments.IsRaw(from_index, num_type_params)) {
         // Other type can't be more specific than this one because for that
         // it would have to have all dynamic type arguments which is checked
         // above.
         return test_kind == Class::kIsSubtypeOf;
       }
-      return type_arguments.TypeTest(test_kind,
-                                     other_type_arguments,
-                                     from_index,
-                                     num_type_params,
-                                     bound_error,
-                                     bound_trail,
-                                     space);
+      return type_arguments.TypeTest(test_kind, other_type_arguments,
+                                     from_index, num_type_params, bound_error,
+                                     bound_trail, space);
     }
     if (other.IsDartFunctionClass()) {
       // Check if type S has a call() method.
-      Function& function = Function::Handle(zone,
-          thsi.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
+      Function& function = Function::Handle(
+          zone, thsi.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
       if (function.IsNull()) {
         // Walk up the super_class chain.
         Class& cls = Class::Handle(zone, thsi.SuperClass());
         while (!cls.IsNull() && function.IsNull()) {
           function = cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
           cls = cls.SuperClass();
         }
       }
       if (!function.IsNull()) {
         return true;
@@ skipping 10 matching lines @@
       interface ^= interfaces.At(i);
       if (!interface.IsFinalized()) {
         // We may be checking bounds at finalization time and can encounter
         // a still unfinalized interface.
         if (interface.IsBeingFinalized()) {
           // Interface is part of a still unfinalized recursive type graph.
           // Skip it. The caller will create a bounded type to be checked at
           // runtime if this type test returns false at compile time.
           continue;
         }
-        ClassFinalizer::FinalizeType(
-            thsi, interface, ClassFinalizer::kCanonicalize);
+        ClassFinalizer::FinalizeType(thsi, interface,
+                                     ClassFinalizer::kCanonicalize);
         interfaces.SetAt(i, interface);
       }
       if (interface.IsMalbounded()) {
         // Return the first bound error to the caller if it requests it.
         if ((bound_error != NULL) && bound_error->IsNull()) {
           *bound_error = interface.error();
         }
         continue;  // Another interface may work better.
       }
       interface_class = interface.type_class();
       interface_args = interface.arguments();
       if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
         // This type class implements an interface that is parameterized with
         // generic type(s), e.g. it implements List<T>.
         // The uninstantiated type T must be instantiated using the type
         // parameters of this type before performing the type test.
         // The type arguments of this type that are referred to by the type
         // parameters of the interface are at the end of the type vector,
         // after the type arguments of the super type of this type.
         // The index of the type parameters is adjusted upon finalization.
         error = Error::null();
-        interface_args =
-            interface_args.InstantiateFrom(type_arguments,
-                                           &error,
-                                           NULL,
-                                           bound_trail,
-                                           space);
+        interface_args = interface_args.InstantiateFrom(
+            type_arguments, &error, NULL, bound_trail, space);
         if (!error.IsNull()) {
           // Return the first bound error to the caller if it requests it.
           if ((bound_error != NULL) && bound_error->IsNull()) {
             *bound_error = error.raw();
           }
           continue;  // Another interface may work better.
         }
       }
-      if (interface_class.TypeTest(test_kind,
-                                   interface_args,
-                                   other,
-                                   other_type_arguments,
-                                   bound_error,
-                                   bound_trail,
-                                   space)) {
+      if (interface_class.TypeTest(test_kind, interface_args, other,
+                                   other_type_arguments, bound_error,
+                                   bound_trail, space)) {
         return true;
       }
     }
     // "Recurse" up the class hierarchy until we have reached the top.
     thsi = thsi.SuperClass();
     if (thsi.IsNull()) {
       return false;
     }
   }
   UNREACHABLE();
   return false;
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if type S is a subtype of type T.
 // If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
 // Type S is specified by this class parameterized with 'type_arguments', and
 // type T by class 'other' parameterized with 'other_type_arguments'.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
 bool Class::TypeTest(TypeTestKind test_kind,
                      const TypeArguments& type_arguments,
                      const Class& other,
                      const TypeArguments& other_type_arguments,
                      Error* bound_error,
                      TrailPtr bound_trail,
                      Heap::Space space) const {
-  return TypeTestNonRecursive(*this,
-                              test_kind,
-                              type_arguments,
-                              other,
-                              other_type_arguments,
-                              bound_error,
-                              bound_trail,
+  return TypeTestNonRecursive(*this, test_kind, type_arguments, other,
+                              other_type_arguments, bound_error, bound_trail,
                               space);
 }
 
 
 bool Class::IsTopLevel() const {
   return Name() == Symbols::TopLevel().raw();
 }
 
 
 bool Class::IsPrivate() const {
@@ skipping 116 matching lines @@
   }
   REUSABLE_ARRAY_HANDLESCOPE(thread);
   REUSABLE_FUNCTION_HANDLESCOPE(thread);
   Array& funcs = thread->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   Function& function = thread->FunctionHandle();
   if (len >= kFunctionLookupHashTreshold) {
     // Cache functions hash table to allow multi threaded access.
-    const Array& hash_table = Array::Handle(thread->zone(),
-                                            raw_ptr()->functions_hash_table_);
+    const Array& hash_table =
+        Array::Handle(thread->zone(), raw_ptr()->functions_hash_table_);
     if (!hash_table.IsNull()) {
       ClassFunctionsSet set(hash_table.raw());
       REUSABLE_STRING_HANDLESCOPE(thread);
       function ^= set.GetOrNull(FunctionName(name, &(thread->StringHandle())));
       // No mutations.
       ASSERT(set.Release().raw() == hash_table.raw());
       return function.IsNull() ? Function::null()
                                : CheckFunctionType(function, kind);
     }
   }
@@ skipping 207 matching lines @@
   }
   return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* patch_prefix = is_patch() ? "Patch " : "";
   const char* class_name = String::Handle(Name()).ToCString();
-  return OS::SCreate(Thread::Current()->zone(),
-      "%s %sClass: %s", library_name, patch_prefix, class_name);
+  return OS::SCreate(Thread::Current()->zone(), "%s %sClass: %s", library_name,
+                     patch_prefix, class_name);
 }
 
 
 // Returns an instance of Double or Double::null().
 // 'index' points to either:
 // - constants_list_ position of found element, or
 // - constants_list_ position where new canonical can be inserted.
-RawDouble* Class::LookupCanonicalDouble(
-    Zone* zone, double value, intptr_t* index) const {
+RawDouble* Class::LookupCanonicalDouble(Zone* zone,
+                                        double value,
+                                        intptr_t* index) const {
   ASSERT(this->raw() == Isolate::Current()->object_store()->double_class());
   const Array& constants = Array::Handle(zone, this->constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Double& canonical_value = Double::Handle(zone);
   while (*index < constants_len) {
     canonical_value ^= constants.At(*index);
     if (canonical_value.IsNull()) {
       break;
     }
     if (canonical_value.BitwiseEqualsToDouble(value)) {
       ASSERT(canonical_value.IsCanonical());
       return canonical_value.raw();
     }
     *index = *index + 1;
   }
   return Double::null();
 }
 
 
-RawMint* Class::LookupCanonicalMint(
-    Zone* zone, int64_t value, intptr_t* index) const {
+RawMint* Class::LookupCanonicalMint(Zone* zone,
+                                    int64_t value,
+                                    intptr_t* index) const {
   ASSERT(this->raw() == Isolate::Current()->object_store()->mint_class());
   const Array& constants = Array::Handle(zone, this->constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Mint& canonical_value = Mint::Handle(zone);
   while (*index < constants_len) {
     canonical_value ^= constants.At(*index);
     if (canonical_value.IsNull()) {
       break;
@@ skipping 38 matching lines @@
     ASSERT(!(key.IsString() || key.IsInteger() || key.IsAbstractType()));
   }
   bool Matches(const Instance& obj) const {
     ASSERT(!(obj.IsString() || obj.IsInteger() || obj.IsAbstractType()));
     if (key_.CanonicalizeEquals(obj)) {
       ASSERT(obj.IsCanonical());
       return true;
     }
     return false;
   }
-  uword Hash() const {
-    return key_.ComputeCanonicalTableHash();
-  }
+  uword Hash() const { return key_.ComputeCanonicalTableHash(); }
   const Instance& key_;
 
  private:
   DISALLOW_ALLOCATION();
 };
 
 
 // Traits for looking up Canonical Instances based on a hash of the fields.
 class CanonicalInstanceTraits {
  public:
   static const char* Name() { return "CanonicalInstanceTraits"; }
   static bool ReportStats() { return false; }
 
   // Called when growing the table.
   static bool IsMatch(const Object& a, const Object& b) {
     ASSERT(!(a.IsString() || a.IsInteger() || a.IsAbstractType()));
     ASSERT(!(b.IsString() || b.IsInteger() || b.IsAbstractType()));
     return a.raw() == b.raw();
   }
   static bool IsMatch(const CanonicalInstanceKey& a, const Object& b) {
     return a.Matches(Instance::Cast(b));
   }
   static uword Hash(const Object& key) {
     ASSERT(!(key.IsString() || key.IsNumber() || key.IsAbstractType()));
     ASSERT(key.IsInstance());
     return Instance::Cast(key).ComputeCanonicalTableHash();
   }
-  static uword Hash(const CanonicalInstanceKey& key) {
-    return key.Hash();
-  }
+  static uword Hash(const CanonicalInstanceKey& key) { return key.Hash(); }
   static RawObject* NewKey(const CanonicalInstanceKey& obj) {
     return obj.key_.raw();
   }
 };
-typedef UnorderedHashSet <CanonicalInstanceTraits> CanonicalInstancesSet;
+typedef UnorderedHashSet<CanonicalInstanceTraits> CanonicalInstancesSet;
 
 
 RawInstance* Class::LookupCanonicalInstance(Zone* zone,
                                             const Instance& value) const {
   ASSERT(this->raw() == value.clazz());
   Instance& canonical_value = Instance::Handle(zone);
   if (this->constants() != Object::empty_array().raw()) {
     CanonicalInstancesSet constants(zone, this->constants());
     canonical_value ^= constants.GetOrNull(CanonicalInstanceKey(value));
     this->set_constants(constants.Release());
@@ skipping 66 matching lines @@
   const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
   type.set_library_prefix(library_prefix);
   type.set_ident(ident);
   type.set_token_pos(token_pos);
   return type.raw();
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New() {
   ASSERT(Object::unresolved_class_class() != Class::null());
-  RawObject* raw = Object::Allocate(UnresolvedClass::kClassId,
-                                    UnresolvedClass::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw = Object::Allocate(
+      UnresolvedClass::kClassId, UnresolvedClass::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_pos(TokenPosition token_pos) const {
   ASSERT(!token_pos.IsClassifying());
   StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
 void UnresolvedClass::set_ident(const String& ident) const {
   StorePointer(&raw_ptr()->ident_, ident.raw());
 }
 
 
 void UnresolvedClass::set_library_prefix(
     const LibraryPrefix& library_prefix) const {
   StorePointer(&raw_ptr()->library_prefix_, library_prefix.raw());
 }
 
 
 RawString* UnresolvedClass::Name() const {
   if (library_prefix() != LibraryPrefix::null()) {
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
-    const LibraryPrefix& lib_prefix = LibraryPrefix::Handle(zone,
-                                                            library_prefix());
+    const LibraryPrefix& lib_prefix =
+        LibraryPrefix::Handle(zone, library_prefix());
     const String& name = String::Handle(zone, lib_prefix.name());  // Qualifier.
     GrowableHandlePtrArray<const String> strs(zone, 3);
     strs.Add(name);
     strs.Add(Symbols::Dot());
     strs.Add(String::Handle(zone, ident()));
     return Symbols::FromConcatAll(thread, strs);
   } else {
     return ident();
   }
 }
 
 
 const char* UnresolvedClass::ToCString() const {
-  const char* cname =  String::Handle(Name()).ToCString();
-  return OS::SCreate(Thread::Current()->zone(),
-      "unresolved class '%s'", cname);
+  const char* cname = String::Handle(Name()).ToCString();
+  return OS::SCreate(Thread::Current()->zone(), "unresolved class '%s'", cname);
 }
 
 
 static uint32_t CombineHashes(uint32_t hash, uint32_t other_hash) {
   hash += other_hash;
   hash += hash << 10;
   hash ^= hash >> 6;  // Logical shift, unsigned hash.
   return hash;
 }
 
@@ skipping 25 matching lines @@
 }
 
 
 RawString* TypeArguments::SubvectorName(intptr_t from_index,
                                         intptr_t len,
                                         NameVisibility name_visibility) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(from_index + len <= Length());
   String& name = String::Handle(zone);
-  const intptr_t num_strings = (len == 0) ? 2 : 2*len + 1;  // "<""T"", ""T"">".
+  const intptr_t num_strings =
+      (len == 0) ? 2 : 2 * len + 1;  // "<""T"", ""T"">".
   GrowableHandlePtrArray<const String> pieces(zone, num_strings);
   pieces.Add(Symbols::LAngleBracket());
   AbstractType& type = AbstractType::Handle(zone);
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     name = type.BuildName(name_visibility);
     pieces.Add(name);
     if (i < len - 1) {
       pieces.Add(Symbols::CommaSpace());
     }
@@ skipping 84 matching lines @@
   ASSERT(Length() >= (from_index + len));
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= (from_index + len));
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(from_index + i);
     ASSERT(!other_type.IsNull());
-    if (!type.TypeTest(test_kind,
-                       other_type,
-                       bound_error,
-                       bound_trail,
+    if (!type.TypeTest(test_kind, other_type, bound_error, bound_trail,
                        space)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::HasInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   return prior_instantiations.Length() > 1;
 }
 
 
 intptr_t TypeArguments::NumInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   intptr_t i = 0;
   while (prior_instantiations.At(i) != Smi::New(StubCode::kNoInstantiator)) {
     i += 2;
   }
-  return i/2;
+  return i / 2;
 }
 
 
 RawArray* TypeArguments::instantiations() const {
   return raw_ptr()->instantiations_;
 }
 
 
 void TypeArguments::set_instantiations(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->instantiations_, value.raw());
 }
 
 
 intptr_t TypeArguments::Length() const {
   ASSERT(!IsNull());
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
   return *TypeAddr(index);
 }
 
 
-void TypeArguments::SetTypeAt(intptr_t index,
-                                const AbstractType& value) const {
+void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
   ASSERT(!IsCanonical());
   StorePointer(TypeAddr(index), value.raw());
 }
 
 
 bool TypeArguments::IsResolved() const {
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
@@ skipping 49 matching lines @@
   return true;
   // Note that it is not necessary to verify at runtime that the instantiator
   // type vector is long enough, since this uninstantiated vector contains as
   // many different type parameters as it is long.
 }
 
 
 // Return true if this uninstantiated type argument vector, once instantiated
 // at runtime, is a prefix of the type argument vector of its instantiator.
 bool TypeArguments::CanShareInstantiatorTypeArguments(
-      const Class& instantiator_class) const {
+    const Class& instantiator_class) const {
   ASSERT(!IsInstantiated());
   const intptr_t num_type_args = Length();
   const intptr_t num_instantiator_type_args =
       instantiator_class.NumTypeArguments();
   if (num_type_args > num_instantiator_type_args) {
     // This vector cannot be a prefix of a shorter vector.
     return false;
   }
   const intptr_t num_instantiator_type_params =
       instantiator_class.NumTypeParameters();
@@ skipping 25 matching lines @@
     if ((type_param.index() != i)) {
       return false;
     }
   }
   // As a second requirement, the type arguments corresponding to the super type
   // must be identical. Overlapping ones have already been checked starting at
   // first_type_param_offset.
   if (first_type_param_offset == 0) {
     return true;
   }
-  AbstractType& super_type = AbstractType::Handle(
-      instantiator_class.super_type());
-  const TypeArguments& super_type_args = TypeArguments::Handle(
-      super_type.arguments());
+  AbstractType& super_type =
+      AbstractType::Handle(instantiator_class.super_type());
+  const TypeArguments& super_type_args =
+      TypeArguments::Handle(super_type.arguments());
   if (super_type_args.IsNull()) {
     return false;
   }
   AbstractType& super_type_arg = AbstractType::Handle();
-  for (intptr_t i = 0;
-       (i < first_type_param_offset) && (i < num_type_args); i++) {
+  for (intptr_t i = 0; (i < first_type_param_offset) && (i < num_type_args);
+       i++) {
     type_arg = TypeAt(i);
     super_type_arg = super_type_args.TypeAt(i);
     if (!type_arg.Equals(super_type_arg)) {
       return false;
     }
   }
   return true;
 }
 
 
@@ skipping 13 matching lines @@
 
 bool TypeArguments::IsBounded() const {
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (type.IsBoundedType()) {
       return true;
     }
     if (type.IsTypeParameter()) {
-      const AbstractType& bound = AbstractType::Handle(
-          TypeParameter::Cast(type).bound());
+      const AbstractType& bound =
+          AbstractType::Handle(TypeParameter::Cast(type).bound());
       if (!bound.IsObjectType() && !bound.IsDynamicType()) {
         return true;
       }
       continue;
     }
-    const TypeArguments& type_args = TypeArguments::Handle(
-        Type::Cast(type).arguments());
+    const TypeArguments& type_args =
+        TypeArguments::Handle(Type::Cast(type).arguments());
     if (!type_args.IsNull() && type_args.IsBounded()) {
       return true;
     }
   }
   return false;
 }
 
 
 RawTypeArguments* TypeArguments::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(!IsInstantiated());
-  if (!instantiator_type_arguments.IsNull() &&
-      IsUninstantiatedIdentity() &&
+  if (!instantiator_type_arguments.IsNull() && IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
       TypeArguments::Handle(TypeArguments::New(num_types, space));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     // If this type argument T is null, the type A containing T in its flattened
     // type argument vector V is recursive and is still being finalized.
     // T is the type argument of a super type of A. T is being instantiated
     // during finalization of V, which is also the instantiator. T depends
     // solely on the type parameters of A and will be replaced by a non-null
     // type before A is marked as finalized.
     if (!type.IsNull() && !type.IsInstantiated()) {
-      type = type.InstantiateFrom(instantiator_type_arguments,
-                                  bound_error,
-                                  instantiation_trail,
-                                  bound_trail,
-                                  space);
+      type = type.InstantiateFrom(instantiator_type_arguments, bound_error,
+                                  instantiation_trail, bound_trail, space);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
 RawTypeArguments* TypeArguments::InstantiateAndCanonicalizeFrom(
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error) const {
@@ skipping 11 matching lines @@
     if (prior_instantiations.At(index) == instantiator_type_arguments.raw()) {
       return TypeArguments::RawCast(prior_instantiations.At(index + 1));
     }
     if (prior_instantiations.At(index) == Smi::New(StubCode::kNoInstantiator)) {
       break;
     }
     index += 2;
   }
   // Cache lookup failed. Instantiate the type arguments.
   TypeArguments& result = TypeArguments::Handle();
-  result = InstantiateFrom(
-      instantiator_type_arguments, bound_error, NULL, NULL, Heap::kOld);
+  result = InstantiateFrom(instantiator_type_arguments, bound_error, NULL, NULL,
+                           Heap::kOld);
   if ((bound_error != NULL) && !bound_error->IsNull()) {
     return result.raw();
   }
   // Instantiation did not result in bound error. Canonicalize type arguments.
   result = result.Canonicalize();
   // InstantiateAndCanonicalizeFrom is not reentrant. It cannot have been called
   // indirectly, so the prior_instantiations array cannot have grown.
   ASSERT(prior_instantiations.raw() == instantiations());
   // Add instantiator and result to instantiations array.
   intptr_t length = prior_instantiations.Length();
   if ((index + 2) >= length) {
     // Grow the instantiations array.
     // The initial array is Object::zero_array() of length 1.
-    length = (length > 64) ?
-        (length + 64) :
-        ((length == 1) ? 3 : ((length - 1) * 2 + 1));
+    length = (length > 64) ? (length + 64)
+                           : ((length == 1) ? 3 : ((length - 1) * 2 + 1));
     prior_instantiations =
         Array::Grow(prior_instantiations, length, Heap::kOld);
     set_instantiations(prior_instantiations);
     ASSERT((index + 2) < length);
   }
   prior_instantiations.SetAt(index, instantiator_type_arguments);
   prior_instantiations.SetAt(index + 1, result);
   prior_instantiations.SetAt(index + 2,
                              Smi::Handle(Smi::New(StubCode::kNoInstantiator)));
   return result.raw();
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TypeArguments::New: invalid len %" Pd "\n", len);
   }
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(TypeArguments::kClassId,
-                                      TypeArguments::InstanceSize(len),
-                                      space);
+                                      TypeArguments::InstanceSize(len), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
     result.SetHash(0);
   }
   // The zero array should have been initialized.
   ASSERT(Object::zero_array().raw() != Array::null());
   COMPILE_ASSERT(StubCode::kNoInstantiator == 0);
   result.set_instantiations(Object::zero_array());
   return result.raw();
 }
 
 
-
 RawAbstractType* const* TypeArguments::TypeAddr(intptr_t index) const {
   // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types()[index];
 }
 
 
 void TypeArguments::SetLength(intptr_t value) const {
   ASSERT(!IsCanonical());
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->length_, Smi::New(value));
 }
 
 
 RawTypeArguments* TypeArguments::CloneUnfinalized() const {
   if (IsNull() || IsFinalized()) {
     return raw();
   }
   ASSERT(IsResolved());
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
-  const TypeArguments& clone = TypeArguments::Handle(
-      TypeArguments::New(num_types));
+  const TypeArguments& clone =
+      TypeArguments::Handle(TypeArguments::New(num_types));
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     type = type.CloneUnfinalized();
     clone.SetTypeAt(i, type);
   }
   ASSERT(clone.IsResolved());
   return clone.raw();
 }
 
 
-RawTypeArguments* TypeArguments::CloneUninstantiated(
-    const Class& new_owner,
-    TrailPtr trail) const {
+RawTypeArguments* TypeArguments::CloneUninstantiated(const Class& new_owner,
+                                                     TrailPtr trail) const {
   ASSERT(!IsNull());
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
-  const TypeArguments& clone = TypeArguments::Handle(
-      TypeArguments::New(num_types));
+  const TypeArguments& clone =
+      TypeArguments::Handle(TypeArguments::New(num_types));
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.CloneUninstantiated(new_owner, trail);
     }
     clone.SetTypeAt(i, type);
   }
   ASSERT(clone.IsFinalized());
   return clone.raw();
 }
@@ skipping 32 matching lines @@
         return this->raw();
       }
       SetTypeAt(i, type_arg);
     }
     // Canonicalization of a type argument of a recursive type argument vector
     // may change the hash of the vector, so recompute.
     if (IsRecursive()) {
       ComputeHash();
     }
     SafepointMutexLocker ml(isolate->type_canonicalization_mutex());
-    CanonicalTypeArgumentsSet table(
-        zone, object_store->canonical_type_arguments());
+    CanonicalTypeArgumentsSet table(zone,
+                                    object_store->canonical_type_arguments());
     // Since we canonicalized some type arguments above we need to lookup
     // in the table again to make sure we don't already have an equivalent
     // canonical entry.
     result ^= table.GetOrNull(CanonicalTypeArgumentsKey(*this));
     if (result.IsNull()) {
       // Make sure we have an old space object and add it to the table.
       if (this->IsNew()) {
         result ^= Object::Clone(*this, Heap::kOld);
       } else {
         result ^= this->raw();
@@ skipping 29 matching lines @@
   }
   return String::ConcatAll(pieces);
 }
 
 
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   Zone* zone = Thread::Current()->zone();
-  const char* prev_cstr = OS::SCreate(
-      zone, "TypeArguments: (%" Pd ")", Smi::Value(raw_ptr()->hash_));
+  const char* prev_cstr = OS::SCreate(zone, "TypeArguments: (%" Pd ")",
+                                      Smi::Value(raw_ptr()->hash_));
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(zone, TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     char* chars = OS::SCreate(zone, "%s [%s]", prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 const char* PatchClass::ToCString() const {
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
-  return OS::SCreate(Thread::Current()->zone(),
-      "PatchClass for %s", cls_name);
+  return OS::SCreate(Thread::Current()->zone(), "PatchClass for %s", cls_name);
 }
 
 
 RawPatchClass* PatchClass::New(const Class& patched_class,
                                const Class& origin_class) {
   const PatchClass& result = PatchClass::Handle(PatchClass::New());
   result.set_patched_class(patched_class);
   result.set_origin_class(origin_class);
   result.set_script(Script::Handle(origin_class.script()));
   return result.raw();
 }
 
 
 RawPatchClass* PatchClass::New(const Class& patched_class,
                                const Script& script) {
   const PatchClass& result = PatchClass::Handle(PatchClass::New());
   result.set_patched_class(patched_class);
   result.set_origin_class(patched_class);
   result.set_script(script);
   return result.raw();
 }
 
 
 RawPatchClass* PatchClass::New() {
   ASSERT(Object::patch_class_class() != Class::null());
   RawObject* raw = Object::Allocate(PatchClass::kClassId,
-                                    PatchClass::InstanceSize(),
-                                    Heap::kOld);
+                                    PatchClass::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawPatchClass*>(raw);
 }
 
 
 void PatchClass::set_patched_class(const Class& value) const {
   StorePointer(&raw_ptr()->patched_class_, value.raw());
 }
 
 
 void PatchClass::set_origin_class(const Class& value) const {
@@ skipping 41 matching lines @@
   StoreNonPointer(&raw_ptr()->entry_point_, value.UncheckedEntryPoint());
 }
 
 
 void Function::AttachCode(const Code& value) const {
   DEBUG_ASSERT(IsMutatorOrAtSafepoint());
   // Finish setting up code before activating it.
   value.set_owner(*this);
   SetInstructions(value);
   ASSERT(Function::Handle(value.function()).IsNull() ||
-      (value.function() == this->raw()));
+         (value.function() == this->raw()));
 }
 
 
 bool Function::HasCode() const {
   ASSERT(raw_ptr()->code_ != Code::null());
   return raw_ptr()->code_ != StubCode::LazyCompile_entry()->code();
 }
 
 
 void Function::ClearCode() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   ASSERT(Thread::Current()->IsMutatorThread());
   StorePointer(&raw_ptr()->unoptimized_code_, Code::null());
   SetInstructions(Code::Handle(StubCode::LazyCompile_entry()->code()));
 #endif
 }
 
 
 void Function::EnsureHasCompiledUnoptimizedCode() const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(thread->IsMutatorThread());
 
-  const Error& error = Error::Handle(zone,
-      Compiler::EnsureUnoptimizedCode(thread, *this));
+  const Error& error =
+      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, *this));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 }
 
 
 void Function::SwitchToUnoptimizedCode() const {
   ASSERT(HasOptimizedCode());
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   ASSERT(thread->IsMutatorThread());
   const Code& current_code = Code::Handle(zone, CurrentCode());
 
   if (FLAG_trace_deoptimization_verbose) {
     THR_Print("Disabling optimized code: '%s' entry: %#" Px "\n",
-      ToFullyQualifiedCString(),
-      current_code.UncheckedEntryPoint());
+              ToFullyQualifiedCString(), current_code.UncheckedEntryPoint());
   }
   current_code.DisableDartCode();
-  const Error& error = Error::Handle(zone,
-      Compiler::EnsureUnoptimizedCode(thread, *this));
+  const Error& error =
+      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, *this));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
   const Code& unopt_code = Code::Handle(zone, unoptimized_code());
   AttachCode(unopt_code);
   unopt_code.Enable();
   isolate->TrackDeoptimizedCode(current_code);
 }
 
 
@@ skipping 139 matching lines @@
     field ^= fields.At(i);
     ASSERT(!field.IsNull());
     if (field.token_pos() == token_pos()) {
       return field.raw();
     }
   }
   return Field::null();
 }
 
 
-
 RawFunction* Function::parent_function() const {
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     return ClosureData::Cast(obj).parent_function();
   } else if (IsSignatureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     // Parent function may be null or data_ may already be set to function type.
     if (!obj.IsNull() && obj.IsFunction()) {
       return Function::Cast(obj).raw();
@@ skipping 11 matching lines @@
     return;
   } else if (IsSignatureFunction()) {
     set_data(value);  // Temporarily set during parsing only.
     return;
   }
   UNREACHABLE();
 }
 
 
 RawFunction* Function::implicit_closure_function() const {
-  if (IsClosureFunction() ||
-      IsSignatureFunction() ||
-      IsFactory()) {
+  if (IsClosureFunction() || IsSignatureFunction() || IsFactory()) {
     return Function::null();
   }
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsNull() || obj.IsScript() || obj.IsFunction() || obj.IsArray());
   if (obj.IsNull() || obj.IsScript()) {
     return Function::null();
   }
   if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
   }
@@ skipping 40 matching lines @@
     // In case of a function type alias, the function owner is the alias class,
     // i.e. the typedef. The signature type is therefore parameterized according
     // to the alias class declaration, even if the function type is not generic.
     // Otherwise, if the function is static or if its signature type is
     // non-generic, i.e. it does not depend on any type parameter of the owner
     // class, then the signature type is not parameterized, although the owner
     // class may be. In this case, the scope class of the function type is reset
     // to _Closure class as well as the owner of the signature function.
     Class& scope_class = Class::Handle(Owner());
     if (!scope_class.IsTypedefClass() &&
-        (is_static() ||
-         !scope_class.IsGeneric() ||
+        (is_static() || !scope_class.IsGeneric() ||
          HasInstantiatedSignature())) {
       scope_class = Isolate::Current()->object_store()->closure_class();
       if (IsSignatureFunction()) {
         set_owner(scope_class);
         set_token_pos(TokenPosition::kNoSource);
       }
     }
     const TypeArguments& signature_type_arguments =
         TypeArguments::Handle(scope_class.type_parameters());
     // Return the still unfinalized signature type.
@@ skipping 223 matching lines @@
   StorePointer(&raw_ptr()->result_type_, value.raw());
 }
 
 
 RawAbstractType* Function::ParameterTypeAt(intptr_t index) const {
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
   return AbstractType::RawCast(parameter_types.At(index));
 }
 
 
-void Function::SetParameterTypeAt(
-    intptr_t index, const AbstractType& value) const {
+void Function::SetParameterTypeAt(intptr_t index,
+                                  const AbstractType& value) const {
   ASSERT(!value.IsNull());
   // Method extractor parameters are shared and are in the VM heap.
   ASSERT(kind() != RawFunction::kMethodExtractor);
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
   parameter_types.SetAt(index, value);
 }
 
 
 void Function::set_parameter_types(const Array& value) const {
   StorePointer(&raw_ptr()->parameter_types_, value.raw());
@@ skipping 28 matching lines @@
     return 0;
   }
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   type_params = type_parameters();
   return type_params.Length();
 }
 
 
 RawTypeParameter* Function::LookupTypeParameter(
-    const String& type_name, intptr_t* function_level) const {
+    const String& type_name,
+    intptr_t* function_level) const {
   ASSERT(!type_name.IsNull());
   Thread* thread = Thread::Current();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   REUSABLE_TYPE_PARAMETER_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
   REUSABLE_FUNCTION_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
-  TypeParameter&  type_param = thread->TypeParameterHandle();
+  TypeParameter& type_param = thread->TypeParameterHandle();
   String& type_param_name = thread->StringHandle();
   Function& function = thread->FunctionHandle();
 
   function ^= this->raw();
   intptr_t parent_level = -1;
   while (!function.IsNull()) {
     type_params ^= function.type_parameters();
     if (!type_params.IsNull()) {
       parent_level++;
       const intptr_t num_type_params = type_params.Length();
@@ skipping 61 matching lines @@
   // A positive value indicates positional params, a negative one named params.
   ASSERT(Utils::IsInt(16, value));
   StoreNonPointer(&raw_ptr()->num_optional_parameters_,
                   static_cast<int16_t>(value));
 }
 
 
 void Function::SetNumOptionalParameters(intptr_t num_optional_parameters,
                                         bool are_optional_positional) const {
   ASSERT(num_optional_parameters >= 0);
-  set_num_optional_parameters(are_optional_positional ?
-                              num_optional_parameters :
-                              -num_optional_parameters);
+  set_num_optional_parameters(are_optional_positional
+                                  ? num_optional_parameters
+                                  : -num_optional_parameters);
 }
 
 
 bool Function::IsOptimizable() const {
   if (FLAG_precompiled_mode) {
     return true;
   }
   if (is_native()) {
     // Native methods don't need to be optimized.
     return false;
   }
   const intptr_t function_length = end_token_pos().Pos() - token_pos().Pos();
   if (is_optimizable() && (script() != Script::null()) &&
       (function_length < FLAG_huge_method_cutoff_in_tokens)) {
     // Additional check needed for implicit getters.
     return (unoptimized_code() == Object::null()) ||
-        (Code::Handle(unoptimized_code()).Size() <
+           (Code::Handle(unoptimized_code()).Size() <
             FLAG_huge_method_cutoff_in_code_size);
   }
   return false;
 }
 
 
 bool Function::IsNativeAutoSetupScope() const {
   return is_native() ? is_optimizable() : false;
 }
 
 
 void Function::SetIsOptimizable(bool value) const {
   ASSERT(!is_native());
   set_is_optimizable(value);
   if (!value) {
     set_is_inlinable(false);
     set_usage_counter(INT_MIN);
   }
 }
 
 
 void Function::SetIsNativeAutoSetupScope(bool value) const {
   ASSERT(is_native());
   set_is_optimizable(value);
 }
 
 
 bool Function::CanBeInlined() const {
   Thread* thread = Thread::Current();
-  return is_inlinable() &&
-         !is_external() &&
-         !is_generated_body() &&
+  return is_inlinable() && !is_external() && !is_generated_body() &&
          (!FLAG_support_debugger ||
           !thread->isolate()->debugger()->HasBreakpoint(*this, thread->zone()));
 }
 
 
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
@@ skipping 18 matching lines @@
 }
 
 
 bool Function::AreValidArgumentCounts(intptr_t num_arguments,
                                       intptr_t num_named_arguments,
                                       String* error_message) const {
   if (num_named_arguments > NumOptionalNamedParameters()) {
     if (error_message != NULL) {
       const intptr_t kMessageBufferSize = 64;
       char message_buffer[kMessageBufferSize];
-      OS::SNPrint(message_buffer,
-                  kMessageBufferSize,
+      OS::SNPrint(message_buffer, kMessageBufferSize,
                   "%" Pd " named passed, at most %" Pd " expected",
-                  num_named_arguments,
-                  NumOptionalNamedParameters());
+                  num_named_arguments, NumOptionalNamedParameters());
       // Allocate in old space because it can be invoked in background
       // optimizing compilation.
       *error_message = String::New(message_buffer, Heap::kOld);
     }
     return false;  // Too many named arguments.
   }
   const intptr_t num_pos_args = num_arguments - num_named_arguments;
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_pos_params = num_fixed_parameters() + num_opt_pos_params;
   if (num_pos_args > num_pos_params) {
     if (error_message != NULL) {
       const intptr_t kMessageBufferSize = 64;
       char message_buffer[kMessageBufferSize];
       // Hide implicit parameters to the user.
       const intptr_t num_hidden_params = NumImplicitParameters();
-      OS::SNPrint(message_buffer,
-                  kMessageBufferSize,
+      OS::SNPrint(message_buffer, kMessageBufferSize,
                   "%" Pd "%s passed, %s%" Pd " expected",
                   num_pos_args - num_hidden_params,
                   num_opt_pos_params > 0 ? " positional" : "",
                   num_opt_pos_params > 0 ? "at most " : "",
                   num_pos_params - num_hidden_params);
       // Allocate in old space because it can be invoked in background
       // optimizing compilation.
       *error_message = String::New(message_buffer, Heap::kOld);
     }
     return false;  // Too many fixed and/or positional arguments.
   }
   if (num_pos_args < num_fixed_parameters()) {
     if (error_message != NULL) {
       const intptr_t kMessageBufferSize = 64;
       char message_buffer[kMessageBufferSize];
       // Hide implicit parameters to the user.
       const intptr_t num_hidden_params = NumImplicitParameters();
-      OS::SNPrint(message_buffer,
-                  kMessageBufferSize,
+      OS::SNPrint(message_buffer, kMessageBufferSize,
                   "%" Pd "%s passed, %s%" Pd " expected",
                   num_pos_args - num_hidden_params,
                   num_opt_pos_params > 0 ? " positional" : "",
                   num_opt_pos_params > 0 ? "at least " : "",
                   num_fixed_parameters() - num_hidden_params);
       // Allocate in old space because it can be invoked in background
       // optimizing compilation.
       *error_message = String::New(message_buffer, Heap::kOld);
     }
     return false;  // Too few fixed and/or positional arguments.
   }
   return true;
 }
 
 
 bool Function::AreValidArguments(intptr_t num_arguments,
                                  const Array& argument_names,
                                  String* error_message) const {
   const intptr_t num_named_arguments =
       argument_names.IsNull() ? 0 : argument_names.Length();
-  if (!AreValidArgumentCounts(num_arguments,
-                              num_named_arguments,
+  if (!AreValidArgumentCounts(num_arguments, num_named_arguments,
                               error_message)) {
     return false;
   }
   // Verify that all argument names are valid parameter names.
   Zone* zone = Thread::Current()->zone();
   String& argument_name = String::Handle(zone);
   String& parameter_name = String::Handle(zone);
   for (intptr_t i = 0; i < num_named_arguments; i++) {
     argument_name ^= argument_names.At(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const intptr_t num_positional_args = num_arguments - num_named_arguments;
     const intptr_t num_parameters = NumParameters();
-    for (intptr_t j = num_positional_args;
-         !found && (j < num_parameters);
+    for (intptr_t j = num_positional_args; !found && (j < num_parameters);
          j++) {
       parameter_name = ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
         found = true;
       }
     }
     if (!found) {
       if (error_message != NULL) {
         const intptr_t kMessageBufferSize = 64;
         char message_buffer[kMessageBufferSize];
-        OS::SNPrint(message_buffer,
-                    kMessageBufferSize,
+        OS::SNPrint(message_buffer, kMessageBufferSize,
                     "no optional formal parameter named '%s'",
                     argument_name.ToCString());
         // Allocate in old space because it can be invoked in background
         // optimizing compilation.
         *error_message = String::New(message_buffer, Heap::kOld);
       }
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::AreValidArguments(const ArgumentsDescriptor& args_desc,
                                  String* error_message) const {
   const intptr_t num_arguments = args_desc.Count();
   const intptr_t num_named_arguments = args_desc.NamedCount();
 
-  if (!AreValidArgumentCounts(num_arguments,
-                              num_named_arguments,
+  if (!AreValidArgumentCounts(num_arguments, num_named_arguments,
                               error_message)) {
     return false;
   }
   // Verify that all argument names are valid parameter names.
   Zone* zone = Thread::Current()->zone();
   String& argument_name = String::Handle(zone);
   String& parameter_name = String::Handle(zone);
   for (intptr_t i = 0; i < num_named_arguments; i++) {
     argument_name ^= args_desc.NameAt(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const intptr_t num_positional_args = num_arguments - num_named_arguments;
     const int num_parameters = NumParameters();
-    for (intptr_t j = num_positional_args;
-         !found && (j < num_parameters);
+    for (intptr_t j = num_positional_args; !found && (j < num_parameters);
          j++) {
       parameter_name = ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
         found = true;
       }
     }
     if (!found) {
       if (error_message != NULL) {
         const intptr_t kMessageBufferSize = 64;
         char message_buffer[kMessageBufferSize];
-        OS::SNPrint(message_buffer,
-                    kMessageBufferSize,
+        OS::SNPrint(message_buffer, kMessageBufferSize,
                     "no optional formal parameter named '%s'",
                     argument_name.ToCString());
         // Allocate in old space because it can be invoked in background
         // optimizing compilation.
         *error_message = String::New(message_buffer, Heap::kOld);
       }
       return false;
     }
   }
   return true;
@@ skipping 45 matching lines @@
       ASSERT(library_name != NULL);
       lib_class_format = (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
     } else {
       library_name = "";
       lib_class_format = "%s%s.";
     }
     reserve_len +=
         OS::SNPrint(NULL, 0, lib_class_format, library_name, class_name);
     ASSERT(chars != NULL);
     *chars = Thread::Current()->zone()->Alloc<char>(reserve_len + 1);
-    written = OS::SNPrint(
-        *chars, reserve_len + 1, lib_class_format, library_name, class_name);
+    written = OS::SNPrint(*chars, reserve_len + 1, lib_class_format,
+                          library_name, class_name);
   } else {
-    written = ConstructFunctionFullyQualifiedCString(parent,
-                                                     chars,
-                                                     reserve_len,
-                                                     with_lib,
-                                                     lib_kind);
+    written = ConstructFunctionFullyQualifiedCString(parent, chars, reserve_len,
+                                                     with_lib, lib_kind);
   }
   ASSERT(*chars != NULL);
   char* next = *chars + written;
   written += OS::SNPrint(next, reserve_len + 1, function_format, name);
   // Replace ":" with "_".
   while (true) {
     next = strchr(next, ':');
     if (next == NULL) break;
     *next = '_';
   }
@@ skipping 24 matching lines @@
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
   ASSERT(Isolate::Current()->error_on_bad_override());
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
-  if (!TypeTest(kIsSubtypeOf, Object::null_type_arguments(),
-                other, Object::null_type_arguments(), bound_error,
-                Heap::kOld)) {
+  if (!TypeTest(kIsSubtypeOf, Object::null_type_arguments(), other,
+                Object::null_type_arguments(), bound_error, Heap::kOld)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
-        Script::Handle(other.script()),
-        other.token_pos(),
-        Report::AtLocation,
-        Report::kError,
-        Heap::kNew,
+        Script::Handle(other.script()), other.token_pos(), Report::AtLocation,
+        Report::kError, Heap::kNew,
         "signature type '%s' of function '%s' is not a subtype of signature "
         "type '%s' of function '%s' where\n%s%s",
         String::Handle(UserVisibleSignature()).ToCString(),
         String::Handle(UserVisibleName()).ToCString(),
         String::Handle(other.UserVisibleSignature()).ToCString(),
         String::Handle(other.UserVisibleName()).ToCString(),
-        String::Handle(Type::Handle(
-            SignatureType()).EnumerateURIs()).ToCString(),
-        String::Handle(Type::Handle(
-            other.SignatureType()).EnumerateURIs()).ToCString());
+        String::Handle(Type::Handle(SignatureType()).EnumerateURIs())
+            .ToCString(),
+        String::Handle(Type::Handle(other.SignatureType()).EnumerateURIs())
+            .ToCString());
     return false;
   }
   // We should also check that if the other function explicitly specifies a
   // default value for a formal parameter, this function does not specify a
   // different default value for the same parameter. However, this check is not
   // possible in the current implementation, because the default parameter
   // values are not stored in the Function object, but discarded after a
   // function is compiled.
   return true;
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if the type of the specified parameter
 // of this function is a subtype or a supertype of the type of the specified
 // parameter of the other function.
 // If test_kind == kIsMoreSpecificThan, checks if the type of the specified
 // parameter of this function is more specific than the type of the specified
 // parameter of the other function.
 // Note that we do not apply contravariance of parameter types, but covariance
 // of both parameter types and result type.
-bool Function::TestParameterType(
-    TypeTestKind test_kind,
-    intptr_t parameter_position,
-    intptr_t other_parameter_position,
-    const TypeArguments& type_arguments,
-    const Function& other,
-    const TypeArguments& other_type_arguments,
-    Error* bound_error,
-    Heap::Space space) const {
+bool Function::TestParameterType(TypeTestKind test_kind,
+                                 intptr_t parameter_position,
+                                 intptr_t other_parameter_position,
+                                 const TypeArguments& type_arguments,
+                                 const Function& other,
+                                 const TypeArguments& other_type_arguments,
+                                 Error* bound_error,
+                                 Heap::Space space) const {
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(other_parameter_position));
   if (!other_param_type.IsInstantiated()) {
     other_param_type =
-        other_param_type.InstantiateFrom(other_type_arguments,
-                                         bound_error,
+        other_param_type.InstantiateFrom(other_type_arguments, bound_error,
                                          NULL,  // instantiation_trail
                                          NULL,  // bound_trail
                                          space);
     ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
   AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
   if (!param_type.IsInstantiated()) {
-    param_type = param_type.InstantiateFrom(type_arguments,
-                                            bound_error,
+    param_type = param_type.InstantiateFrom(type_arguments, bound_error,
                                             NULL,  // instantiation_trail
                                             NULL,  // bound_trail
                                             space);
     ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (param_type.IsDynamicType()) {
     return test_kind == kIsSubtypeOf;
   }
   if (test_kind == kIsSubtypeOf) {
     if (!param_type.IsSubtypeOf(other_param_type, bound_error, NULL, space) &&
         !other_param_type.IsSubtypeOf(param_type, bound_error, NULL, space)) {
       return false;
     }
   } else {
     ASSERT(test_kind == kIsMoreSpecificThan);
-    if (!param_type.IsMoreSpecificThan(
-            other_param_type, bound_error, NULL, space)) {
+    if (!param_type.IsMoreSpecificThan(other_param_type, bound_error, NULL,
+                                       space)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::TypeTest(TypeTestKind test_kind,
                         const TypeArguments& type_arguments,
                         const Function& other,
@@ skipping 16 matching lines @@
        (other_num_fixed_params - other_num_ignored_params)) ||
       ((num_fixed_params - num_ignored_params + num_opt_pos_params) <
        (other_num_fixed_params - other_num_ignored_params +
         other_num_opt_pos_params)) ||
       (num_opt_named_params < other_num_opt_named_params)) {
     return false;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
-    other_res_type = other_res_type.InstantiateFrom(other_type_arguments,
-                                                    bound_error,
-                                                    NULL, NULL, space);
+    other_res_type = other_res_type.InstantiateFrom(
+        other_type_arguments, bound_error, NULL, NULL, space);
     ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
-      res_type = res_type.InstantiateFrom(type_arguments, bound_error,
-                                          NULL, NULL, space);
+      res_type = res_type.InstantiateFrom(type_arguments, bound_error, NULL,
+                                          NULL, space);
       ASSERT((bound_error == NULL) || bound_error->IsNull());
     }
     if (res_type.IsVoidType()) {
       return false;
     }
     if (test_kind == kIsSubtypeOf) {
       if (!res_type.IsSubtypeOf(other_res_type, bound_error, NULL, space) &&
           !other_res_type.IsSubtypeOf(res_type, bound_error, NULL, space)) {
         return false;
       }
     } else {
       ASSERT(test_kind == kIsMoreSpecificThan);
-      if (!res_type.IsMoreSpecificThan(other_res_type, bound_error,
-                                       NULL, space)) {
+      if (!res_type.IsMoreSpecificThan(other_res_type, bound_error, NULL,
+                                       space)) {
         return false;
       }
     }
   }
   // Check the types of fixed and optional positional parameters.
   for (intptr_t i = 0; i < (other_num_fixed_params - other_num_ignored_params +
-                            other_num_opt_pos_params); i++) {
-    if (!TestParameterType(test_kind,
-                           i + num_ignored_params, i + other_num_ignored_params,
-                           type_arguments, other, other_type_arguments,
-                           bound_error,
-                           space)) {
+                            other_num_opt_pos_params);
+       i++) {
+    if (!TestParameterType(test_kind, i + num_ignored_params,
+                           i + other_num_ignored_params, type_arguments, other,
+                           other_type_arguments, bound_error, space)) {
       return false;
     }
   }
   // Check the names and types of optional named parameters.
   if (other_num_opt_named_params == 0) {
     return true;
   }
   // Check that for each optional named parameter of type T of the other
   // function type, there exists an optional named parameter of this function
   // type with an identical name and with a type S that is a either a subtype
   // or supertype of T (if test_kind == kIsSubtypeOf) or that is more specific
   // than T (if test_kind == kIsMoreSpecificThan).
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
   const int num_params = num_fixed_params + num_opt_named_params;
   const int other_num_params =
       other_num_fixed_params + other_num_opt_named_params;
   bool found_param_name;
   String& other_param_name = String::Handle();
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     ASSERT(other_param_name.IsSymbol());
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
       ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
-        if (!TestParameterType(test_kind,
-                               j, i,
-                               type_arguments, other, other_type_arguments,
-                               bound_error,
-                               space)) {
+        if (!TestParameterType(test_kind, j, i, type_arguments, other,
+                               other_type_arguments, bound_error, space)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
       return false;
     }
   }
   return true;
@@ skipping 27 matching lines @@
     return false;
   }
   RawClosureData* data = reinterpret_cast<RawClosureData*>(func->ptr()->data_);
   RawFunction* parent_function = data->ptr()->parent_function_;
   return (parent_function->ptr()->data_ == reinterpret_cast<RawObject*>(func));
 }
 
 
 bool Function::IsConstructorClosureFunction() const {
   return IsClosureFunction() &&
-      String::Handle(name()).StartsWith(Symbols::ConstructorClosurePrefix());
+         String::Handle(name()).StartsWith(Symbols::ConstructorClosurePrefix());
 }
 
 
 RawFunction* Function::New() {
   ASSERT(Object::function_class() != Class::null());
   RawObject* raw = Object::Allocate(Function::kClassId,
-                                    Function::InstanceSize(),
-                                    Heap::kOld);
+                                    Function::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawFunction*>(raw);
 }
 
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            bool is_abstract,
                            bool is_external,
                            bool is_native,
                            const Object& owner,
                            TokenPosition token_pos) {
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Object::empty_array());
   result.set_parameter_names(Object::empty_array());
   result.set_name(name);
   result.set_kind(kind);
   result.set_recognized_kind(MethodRecognizer::kUnknown);
   result.set_modifier(RawFunction::kNoModifier);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
   result.set_is_native(is_native);
   result.set_is_reflectable(true);  // Will be computed later.
-  result.set_is_visible(true);  // Will be computed later.
-  result.set_is_debuggable(true);  // Will be computed later.
+  result.set_is_visible(true);      // Will be computed later.
+  result.set_is_debuggable(true);   // Will be computed later.
   result.set_is_intrinsic(false);
   result.set_is_redirecting(false);
   result.set_is_generated_body(false);
   result.set_always_inline(false);
   result.set_is_polymorphic_target(false);
   NOT_IN_PRECOMPILED(result.set_was_compiled(false));
   result.set_owner(owner);
   NOT_IN_PRECOMPILED(result.set_token_pos(token_pos));
   NOT_IN_PRECOMPILED(result.set_end_token_pos(token_pos));
   result.set_num_fixed_parameters(0);
@@ skipping 52 matching lines @@
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           TokenPosition token_pos) {
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
   ASSERT(!parent_owner.IsNull());
   const Function& result = Function::Handle(
-      Function::New(name,
-                    RawFunction::kClosureFunction,
+      Function::New(name, RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
-                    /* is_native = */ false,
-                    parent_owner,
-                    token_pos));
+                    /* is_native = */ false, parent_owner, token_pos));
   result.set_parent_function(parent);
   return result.raw();
 }
 
 
 RawFunction* Function::NewSignatureFunction(const Class& owner,
                                             TokenPosition token_pos) {
   const Function& result = Function::Handle(Function::New(
-      Symbols::AnonymousSignature(),
-      RawFunction::kSignatureFunction,
+      Symbols::AnonymousSignature(), RawFunction::kSignatureFunction,
       /* is_static = */ false,
       /* is_const = */ false,
       /* is_abstract = */ false,
       /* is_external = */ false,
       /* is_native = */ false,
       owner,  // Same as function type scope class.
       token_pos));
   result.set_is_reflectable(false);
   result.set_is_visible(false);
   result.set_is_debuggable(false);
   return result.raw();
 }
 
 
 RawFunction* Function::NewEvalFunction(const Class& owner,
                                        const Script& script,
                                        bool is_static) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  const Function& result = Function::Handle(zone,
+  const Function& result = Function::Handle(
+      zone,
       Function::New(String::Handle(Symbols::New(thread, ":Eval")),
-                    RawFunction::kRegularFunction,
-                    is_static,
+                    RawFunction::kRegularFunction, is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
-                    /* is_native = */ false,
-                    owner,
-                    TokenPosition::kMinSource));
+                    /* is_native = */ false, owner, TokenPosition::kMinSource));
   ASSERT(!script.IsNull());
   result.set_is_debuggable(false);
   result.set_is_visible(true);
   result.set_eval_script(script);
   return result.raw();
 }
 
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());
-  const Function& closure_function = Function::Handle(
-      NewClosureFunction(closure_name, *this, token_pos()));
+  const Function& closure_function =
+      Function::Handle(NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   if (is_static()) {
     closure_function.set_context_scope(Object::empty_context_scope());
   } else {
     const ContextScope& context_scope =
         ContextScope::Handle(LocalScope::CreateImplicitClosureScope(*this));
     closure_function.set_context_scope(context_scope);
   }
 
@@ skipping 12 matching lines @@
   // removing the receiver if this is an instance method and adding the closure
   // object as first parameter.
   const int kClosure = 1;
   const int has_receiver = is_static() ? 0 : 1;
   const int num_fixed_params = kClosure - has_receiver + num_fixed_parameters();
   const int num_opt_params = NumOptionalParameters();
   const bool has_opt_pos_params = HasOptionalPositionalParameters();
   const int num_params = num_fixed_params + num_opt_params;
   closure_function.set_num_fixed_parameters(num_fixed_params);
   closure_function.SetNumOptionalParameters(num_opt_params, has_opt_pos_params);
-  closure_function.set_parameter_types(Array::Handle(Array::New(num_params,
-                                                                Heap::kOld)));
-  closure_function.set_parameter_names(Array::Handle(Array::New(num_params,
-                                                                Heap::kOld)));
+  closure_function.set_parameter_types(
+      Array::Handle(Array::New(num_params, Heap::kOld)));
+  closure_function.set_parameter_names(
+      Array::Handle(Array::New(num_params, Heap::kOld)));
   AbstractType& param_type = AbstractType::Handle();
   String& param_name = String::Handle();
   // Add implicit closure object parameter.
   param_type = Type::DynamicType();
   closure_function.SetParameterTypeAt(0, param_type);
   closure_function.SetParameterNameAt(0, Symbols::ClosureParameter());
   for (int i = kClosure; i < num_params; i++) {
     param_type = ParameterTypeAt(has_receiver - kClosure + i);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(has_receiver - kClosure + i);
     closure_function.SetParameterNameAt(i, param_name);
   }
   closure_function.set_kernel_function(kernel_function());
 
   const Type& signature_type = Type::Handle(closure_function.SignatureType());
   if (!signature_type.IsFinalized()) {
-    ClassFinalizer::FinalizeType(
-        Class::Handle(Owner()), signature_type, ClassFinalizer::kCanonicalize);
+    ClassFinalizer::FinalizeType(Class::Handle(Owner()), signature_type,
+                                 ClassFinalizer::kCanonicalize);
   }
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 void Function::DropUncompiledImplicitClosureFunction() const {
   if (implicit_closure_function() != Function::null()) {
     const Function& func = Function::Handle(implicit_closure_function());
     if (!func.HasCode()) {
       set_implicit_closure_function(Function::Handle());
     }
   }
 }
 
 
 RawString* Function::UserVisibleFormalParameters() const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   // Typically 3, 5,.. elements in 'pieces', e.g.:
   // '_LoadRequest', CommaSpace, '_LoadError'.
   GrowableHandlePtrArray<const String> pieces(zone, 5);
   const TypeArguments& instantiator = TypeArguments::Handle(zone);
-  BuildSignatureParameters(thread, zone,
-                           false, kUserVisibleName, instantiator, &pieces);
+  BuildSignatureParameters(thread, zone, false, kUserVisibleName, instantiator,
+                           &pieces);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 void Function::BuildSignatureParameters(
     Thread* thread,
     Zone* zone,
     bool instantiate,
     NameVisibility name_visibility,
     const TypeArguments& instantiator,
     GrowableHandlePtrArray<const String>* pieces) const {
   AbstractType& param_type = AbstractType::Handle(zone);
   const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   intptr_t i = 0;
   if (name_visibility == kUserVisibleName) {
     // Hide implicit parameters.
     i = NumImplicitParameters();
   }
   String& name = String::Handle(zone);
   while (i < num_fixed_params) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
-    if (instantiate &&
-        param_type.IsFinalized() &&
+    if (instantiate && param_type.IsFinalized() &&
         !param_type.IsInstantiated()) {
-      param_type = param_type.InstantiateFrom(instantiator, NULL,
-                                              NULL, NULL, Heap::kNew);
+      param_type = param_type.InstantiateFrom(instantiator, NULL, NULL, NULL,
+                                              Heap::kNew);
     }
     name = param_type.BuildName(name_visibility);
     pieces->Add(name);
     if (i != (num_params - 1)) {
       pieces->Add(Symbols::CommaSpace());
     }
     i++;
   }
   if (num_opt_params > 0) {
     if (num_opt_pos_params > 0) {
       pieces->Add(Symbols::LBracket());
     } else {
       pieces->Add(Symbols::LBrace());
     }
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       param_type = ParameterTypeAt(i);
-      if (instantiate &&
-          param_type.IsFinalized() &&
+      if (instantiate && param_type.IsFinalized() &&
           !param_type.IsInstantiated()) {
-        param_type = param_type.InstantiateFrom(instantiator, NULL,
-                                                NULL, NULL, Heap::kNew);
+        param_type = param_type.InstantiateFrom(instantiator, NULL, NULL, NULL,
+                                                Heap::kNew);
       }
       ASSERT(!param_type.IsNull());
       name = param_type.BuildName(name_visibility);
       pieces->Add(name);
       // The parameter name of an optional positional parameter does not need
       // to be part of the signature, since it is not used.
       if (num_opt_named_params > 0) {
         name = ParameterNameAt(i);
         pieces->Add(Symbols::Blank());
         pieces->Add(name);
@@ skipping 51 matching lines @@
   GrowableHandlePtrArray<const String> pieces(zone, 4);
   String& name = String::Handle(zone);
   if (!instantiate && !is_static() && (name_visibility == kInternalName)) {
     // Prefix the signature with its scope class and type parameters, if any
     // (e.g. "Map<K, V>(K) => bool"). In case of a function type alias, the
     // scope class name is the alias name.
     // The signature of static functions cannot be type parameterized.
     const Class& scope_class = Class::Handle(zone, Owner());
     ASSERT(!scope_class.IsNull());
     if (scope_class.IsGeneric()) {
-      const TypeArguments& type_parameters = TypeArguments::Handle(
-          zone, scope_class.type_parameters());
+      const TypeArguments& type_parameters =
+          TypeArguments::Handle(zone, scope_class.type_parameters());
       const String& scope_class_name = String::Handle(zone, scope_class.Name());
       pieces.Add(scope_class_name);
       const intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(Symbols::LAngleBracket());
       TypeParameter& type_parameter = TypeParameter::Handle(zone);
       AbstractType& bound = AbstractType::Handle(zone);
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         type_parameter ^= type_parameters.TypeAt(i);
         name = type_parameter.name();
         pieces.Add(name);
         bound = type_parameter.bound();
         if (!bound.IsNull() && !bound.IsObjectType()) {
           pieces.Add(Symbols::SpaceExtendsSpace());
           name = bound.BuildName(name_visibility);
           pieces.Add(name);
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(Symbols::CommaSpace());
         }
       }
       pieces.Add(Symbols::RAngleBracket());
     }
   }
   pieces.Add(Symbols::LParen());
-  BuildSignatureParameters(thread, zone,
-                           instantiate,
-                           name_visibility,
-                           instantiator,
-                           &pieces);
+  BuildSignatureParameters(thread, zone, instantiate, name_visibility,
+                           instantiator, &pieces);
   pieces.Add(Symbols::RParenArrow());
   AbstractType& res_type = AbstractType::Handle(zone, result_type());
   if (instantiate && res_type.IsFinalized() && !res_type.IsInstantiated()) {
-    res_type = res_type.InstantiateFrom(instantiator, NULL,
-                                        NULL, NULL, Heap::kNew);
+    res_type =
+        res_type.InstantiateFrom(instantiator, NULL, NULL, NULL, Heap::kNew);
   }
   name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 bool Function::HasInstantiatedSignature() const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
@@ skipping 68 matching lines @@
 
 RawString* Function::QualifiedName(NameVisibility name_visibility) const {
   ASSERT(name_visibility != kInternalName);  // We never request it.
   // A function's scrubbed name and its user visible name are identical.
   String& result = String::Handle(UserVisibleName());
   if (IsClosureFunction()) {
     Function& fun = Function::Handle(raw());
     while (fun.IsLocalFunction() && !fun.IsImplicitClosureFunction()) {
       fun = fun.parent_function();
       result = String::Concat(Symbols::Dot(), result, Heap::kOld);
-      result = String::Concat(
-          String::Handle(fun.UserVisibleName()), result, Heap::kOld);
+      result = String::Concat(String::Handle(fun.UserVisibleName()), result,
+                              Heap::kOld);
     }
   }
   const Class& cls = Class::Handle(Owner());
   if (!cls.IsTopLevel()) {
     result = String::Concat(Symbols::Dot(), result, Heap::kOld);
-    const String& cls_name = String::Handle(
-        name_visibility == kScrubbedName ? cls.ScrubbedName()
-                                         : cls.UserVisibleName());
+    const String& cls_name = String::Handle(name_visibility == kScrubbedName
+                                                ? cls.ScrubbedName()
+                                                : cls.UserVisibleName());
     result = String::Concat(cls_name, result, Heap::kOld);
   }
   return result.raw();
 }
 
 
 RawString* Function::GetSource() const {
   if (IsImplicitConstructor() || IsSignatureFunction()) {
     // We may need to handle more cases when the restrictions on mixins are
     // relaxed. In particular we might start associating some source with the
@@ skipping 17 matching lines @@
   intptr_t to_col;
   func_script.GetTokenLocation(token_pos(), &from_line, &from_col);
   func_script.GetTokenLocation(end_token_pos(), &to_line, &to_col);
   intptr_t last_tok_len = String::Handle(tkit.CurrentLiteral()).Length();
   // Handle special cases for end tokens of closures (where we exclude the last
   // token):
   // (1) "foo(() => null, bar);": End token is `,', but we don't print it.
   // (2) "foo(() => null);": End token is ')`, but we don't print it.
   // (3) "var foo = () => null;": End token is `;', but in this case the token
   // semicolon belongs to the assignment so we skip it.
-  if ((tkit.CurrentTokenKind() == Token::kCOMMA) ||                   // Case 1.
-      (tkit.CurrentTokenKind() == Token::kRPAREN) ||                  // Case 2.
+  if ((tkit.CurrentTokenKind() == Token::kCOMMA) ||   // Case 1.
+      (tkit.CurrentTokenKind() == Token::kRPAREN) ||  // Case 2.
       (tkit.CurrentTokenKind() == Token::kSEMICOLON &&
        String::Handle(zone, name()).Equals("<anonymous closure>"))) {  // Cas 3.
     last_tok_len = 0;
   }
-  const String& result = String::Handle(zone, func_script.GetSnippet(
-      from_line, from_col, to_line, to_col + last_tok_len));
+  const String& result =
+      String::Handle(zone, func_script.GetSnippet(from_line, from_col, to_line,
+                                                  to_col + last_tok_len));
   ASSERT(!result.IsNull());
   return result.raw();
 }
 
 
 // Construct fingerprint from token stream. The token stream contains also
 // arguments.
 int32_t Function::SourceFingerprint() const {
   uint32_t result = 0;
   Zone* zone = Thread::Current()->zone();
   TokenStream::Iterator tokens_iterator(
-      zone,
-      TokenStream::Handle(zone, Script::Handle(zone, script()).tokens()),
+      zone, TokenStream::Handle(zone, Script::Handle(zone, script()).tokens()),
       token_pos());
   Object& obj = Object::Handle(zone);
   String& literal = String::Handle(zone);
   while (tokens_iterator.CurrentPosition() < end_token_pos()) {
     uint32_t val = 0;
     obj = tokens_iterator.CurrentToken();
     if (obj.IsSmi()) {
       val = Smi::Cast(obj).Value();
     } else {
       literal = tokens_iterator.MakeLiteralToken(obj);
@@ skipping 41 matching lines @@
   ASSERT(deopt_id_to_ic_data->is_empty());
   Zone* zone = Thread::Current()->zone();
   const Array& saved_ic_data = Array::Handle(zone, ic_data_array());
   if (saved_ic_data.IsNull()) {
     // Could happen with deferred loading.
     return;
   }
   const intptr_t saved_length = saved_ic_data.Length();
   ASSERT(saved_length > 0);
   if (saved_length > 1) {
-    const intptr_t restored_length = ICData::Cast(Object::Handle(
-        zone, saved_ic_data.At(saved_length - 1))).deopt_id() + 1;
+    const intptr_t restored_length =
+        ICData::Cast(Object::Handle(zone, saved_ic_data.At(saved_length - 1)))
+            .deopt_id() +
+        1;
     deopt_id_to_ic_data->SetLength(restored_length);
     for (intptr_t i = 0; i < restored_length; i++) {
       (*deopt_id_to_ic_data)[i] = NULL;
     }
     for (intptr_t i = 1; i < saved_length; i++) {
       ICData& ic_data = ICData::ZoneHandle(zone);
       ic_data ^= saved_ic_data.At(i);
       if (clone_ic_data) {
         const ICData& original_ic_data = ICData::Handle(zone, ic_data.raw());
         ic_data = ICData::Clone(ic_data);
@@ skipping 35 matching lines @@
 
 bool Function::CheckSourceFingerprint(const char* prefix, int32_t fp) const {
   if (SourceFingerprint() != fp) {
     const bool recalculatingFingerprints = false;
     if (recalculatingFingerprints) {
       // This output can be copied into a file, then used with sed
       // to replace the old values.
       // sed -i .bak -f /tmp/newkeys runtime/vm/method_recognizer.h
       THR_Print("s/0x%08x/0x%08x/\n", fp, SourceFingerprint());
     } else {
-      THR_Print("FP mismatch while recognizing method %s:"
-                " expecting 0x%08x found 0x%08x\n",
-                ToFullyQualifiedCString(),
-                fp,
-                SourceFingerprint());
+      THR_Print(
+          "FP mismatch while recognizing method %s:"
+          " expecting 0x%08x found 0x%08x\n",
+          ToFullyQualifiedCString(), fp, SourceFingerprint());
       return false;
     }
   }
   return true;
 }
 
 
 const char* Function::ToCString() const {
   const char* static_str = is_static() ? " static" : "";
   const char* abstract_str = is_abstract() ? " abstract" : "";
@@ skipping 30 matching lines @@
     case RawFunction::kInvokeFieldDispatcher:
       kind_str = "invoke-field-dispatcher";
       break;
     case RawFunction::kIrregexpFunction:
       kind_str = "irregexp-function";
       break;
     default:
       UNREACHABLE();
   }
   const char* function_name = String::Handle(name()).ToCString();
-  return OS::SCreate(Thread::Current()->zone(),
-      "Function '%s':%s%s%s%s.",
-      function_name, static_str, abstract_str, kind_str, const_str);
+  return OS::SCreate(Thread::Current()->zone(), "Function '%s':%s%s%s%s.",
+                     function_name, static_str, abstract_str, kind_str,
+                     const_str);
 }
 
 
 void ClosureData::set_context_scope(const ContextScope& value) const {
   StorePointer(&raw_ptr()->context_scope_, value.raw());
 }
 
 
 void ClosureData::set_implicit_static_closure(const Instance& closure) const {
   ASSERT(!closure.IsNull());
   ASSERT(raw_ptr()->closure_ == Instance::null());
   StorePointer(&raw_ptr()->closure_, closure.raw());
 }
 
 
 void ClosureData::set_parent_function(const Function& value) const {
   StorePointer(&raw_ptr()->parent_function_, value.raw());
 }
 
 
 void ClosureData::set_signature_type(const Type& value) const {
   StorePointer(&raw_ptr()->signature_type_, value.raw());
 }
 
 
 RawClosureData* ClosureData::New() {
   ASSERT(Object::closure_data_class() != Class::null());
   RawObject* raw = Object::Allocate(ClosureData::kClassId,
-                                    ClosureData::InstanceSize(),
-                                    Heap::kOld);
+                                    ClosureData::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawClosureData*>(raw);
 }
 
 
 const char* ClosureData::ToCString() const {
   return "ClosureData class";
 }
 
 
 void RedirectionData::set_type(const Type& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 void RedirectionData::set_identifier(const String& value) const {
   StorePointer(&raw_ptr()->identifier_, value.raw());
 }
 
 
 void RedirectionData::set_target(const Function& value) const {
   StorePointer(&raw_ptr()->target_, value.raw());
 }
 
 
 RawRedirectionData* RedirectionData::New() {
   ASSERT(Object::redirection_data_class() != Class::null());
-  RawObject* raw = Object::Allocate(RedirectionData::kClassId,
-                                    RedirectionData::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw = Object::Allocate(
+      RedirectionData::kClassId, RedirectionData::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawRedirectionData*>(raw);
 }
 
 
 const char* RedirectionData::ToCString() const {
   return "RedirectionData class";
 }
 
 
 RawField* Field::CloneFromOriginal() const {
@@ skipping 46 matching lines @@
 }
 
 
 RawString* Field::LookupSetterSymbol(const String& field_name) {
   return Symbols::LookupFromSet(Thread::Current(), field_name);
 }
 
 
 RawString* Field::NameFromGetter(const String& getter_name) {
   return Symbols::New(Thread::Current(), getter_name, kGetterPrefixLength,
-      getter_name.Length() - kGetterPrefixLength);
+                      getter_name.Length() - kGetterPrefixLength);
 }
 
 
 RawString* Field::NameFromSetter(const String& setter_name) {
   return Symbols::New(Thread::Current(), setter_name, kSetterPrefixLength,
-      setter_name.Length() - kSetterPrefixLength);
+                      setter_name.Length() - kSetterPrefixLength);
 }
 
 
 bool Field::IsGetterName(const String& function_name) {
   return function_name.StartsWith(Symbols::GetterPrefix());
 }
 
 
 bool Field::IsSetterName(const String& function_name) {
   return function_name.StartsWith(Symbols::SetterPrefix());
@@ skipping 63 matching lines @@
   ASSERT(IsOriginal());
   ASSERT(!value.IsNull());
   if (value.raw() != type()) {
     StorePointer(&raw_ptr()->type_, value.raw());
   }
 }
 
 
 RawField* Field::New() {
   ASSERT(Object::field_class() != Class::null());
-  RawObject* raw = Object::Allocate(Field::kClassId,
-                                    Field::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw =
+      Object::Allocate(Field::kClassId, Field::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 void Field::InitializeNew(const Field& result,
                           const String& name,
                           bool is_static,
                           bool is_final,
                           bool is_const,
                           bool is_reflectable,
@@ skipping 36 matching lines @@
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      bool is_const,
                      bool is_reflectable,
                      const Class& owner,
                      const AbstractType& type,
                      TokenPosition token_pos) {
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
-  InitializeNew(result,
-                name,
-                is_static,
-                is_final,
-                is_const,
-                is_reflectable,
-                owner,
-                token_pos);
+  InitializeNew(result, name, is_static, is_final, is_const, is_reflectable,
+                owner, token_pos);
   result.SetFieldType(type);
   return result.raw();
 }
 
 
 RawField* Field::NewTopLevel(const String& name,
                              bool is_final,
                              bool is_const,
                              const Object& owner,
                              TokenPosition token_pos) {
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
-  InitializeNew(result,
-                name,
-                true, /* is_static */
-                is_final,
-                is_const,
-                true, /* is_reflectable */
-                owner,
-                token_pos);
+  InitializeNew(result, name, true,       /* is_static */
+                is_final, is_const, true, /* is_reflectable */
+                owner, token_pos);
   return result.raw();
 }
 
 
 RawField* Field::Clone(const Class& new_owner) const {
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->Owner());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
@@ skipping 62 matching lines @@
 const char* Field::ToCString() const {
   if (IsNull()) {
     return "Field::null";
   }
   const char* kF0 = is_static() ? " static" : "";
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
   const char* field_name = String::Handle(name()).ToCString();
   const Class& cls = Class::Handle(Owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
-  return OS::SCreate(Thread::Current()->zone(),
-      "Field <%s.%s>:%s%s%s", cls_name, field_name, kF0, kF1, kF2);
+  return OS::SCreate(Thread::Current()->zone(), "Field <%s.%s>:%s%s%s",
+                     cls_name, field_name, kF0, kF1, kF2);
 }
 
 
 // Build a closure object that gets (or sets) the contents of a static
 // field f and cache the closure in a newly created static field
 // named #f (or #f= in case of a setter).
 RawInstance* Field::AccessorClosure(bool make_setter) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(is_static());
   const Class& field_owner = Class::Handle(zone, Owner());
 
   String& closure_name = String::Handle(zone, this->name());
   closure_name = Symbols::FromConcat(thread, Symbols::HashMark(), closure_name);
   if (make_setter) {
-    closure_name = Symbols::FromConcat(thread,
-        Symbols::HashMark(), closure_name);
+    closure_name =
+        Symbols::FromConcat(thread, Symbols::HashMark(), closure_name);
   }
 
   Field& closure_field = Field::Handle(zone);
   closure_field = field_owner.LookupStaticField(closure_name);
   if (!closure_field.IsNull()) {
     ASSERT(closure_field.is_static());
-    const Instance& closure = Instance::Handle(zone,
-        closure_field.StaticValue());
+    const Instance& closure =
+        Instance::Handle(zone, closure_field.StaticValue());
     ASSERT(!closure.IsNull());
     ASSERT(closure.IsClosure());
     return closure.raw();
   }
 
   // This is the first time a closure for this field is requested.
   // Create the closure and a new static field in which it is stored.
   const char* field_name = String::Handle(zone, name()).ToCString();
   String& expr_src = String::Handle(zone);
   if (make_setter) {
-    expr_src =
-        String::NewFormatted("(%s_) { return %s = %s_; }",
-                             field_name, field_name, field_name);
+    expr_src = String::NewFormatted("(%s_) { return %s = %s_; }", field_name,
+                                    field_name, field_name);
   } else {
     expr_src = String::NewFormatted("() { return %s; }", field_name);
   }
-  Object& result = Object::Handle(zone,
-      field_owner.Evaluate(expr_src,
-                           Object::empty_array(),
-                           Object::empty_array()));
+  Object& result =
+      Object::Handle(zone, field_owner.Evaluate(expr_src, Object::empty_array(),
+                                                Object::empty_array()));
   ASSERT(result.IsInstance());
   // The caller may expect the closure to be allocated in old space. Copy
   // the result here, since Object::Clone() is a private method.
   result = Object::Clone(result, Heap::kOld);
 
-  closure_field = Field::New(closure_name,
-                             true,  // is_static
-                             true,  // is_final
-                             true,  // is_const
-                             false,  // is_reflectable
-                             field_owner,
-                             Object::dynamic_type(),
-                             this->token_pos());
+  closure_field =
+      Field::New(closure_name,
+                 true,   // is_static
+                 true,   // is_final
+                 true,   // is_const
+                 false,  // is_reflectable
+                 field_owner, Object::dynamic_type(), this->token_pos());
   closure_field.SetStaticValue(Instance::Cast(result), true);
   field_owner.AddField(closure_field);
 
   return Instance::RawCast(result.raw());
 }
 
 
 RawInstance* Field::GetterClosure() const {
   return AccessorClosure(false);
 }
@@ skipping 12 matching lines @@
 void Field::set_dependent_code(const Array& array) const {
   ASSERT(IsOriginal());
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
 }
 
 
 class FieldDependentArray : public WeakCodeReferences {
  public:
   explicit FieldDependentArray(const Field& field)
       : WeakCodeReferences(Array::Handle(field.dependent_code())),
-                           field_(field) {}
+        field_(field) {}
 
   virtual void UpdateArrayTo(const Array& value) {
     field_.set_dependent_code(value);
   }
 
   virtual void ReportDeoptimization(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       Function& function = Function::Handle(code.function());
       THR_Print("Deoptimizing %s because guard on field %s failed.\n",
                 function.ToFullyQualifiedCString(), field_.ToCString());
     }
   }
 
   virtual void ReportSwitchingCode(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       Function& function = Function::Handle(code.function());
-      THR_Print("Switching '%s' to unoptimized code because guard"
-                " on field '%s' was violated.\n",
-                function.ToFullyQualifiedCString(),
-                field_.ToCString());
+      THR_Print(
+          "Switching '%s' to unoptimized code because guard"
+          " on field '%s' was violated.\n",
+          function.ToFullyQualifiedCString(), field_.ToCString());
     }
   }
 
  private:
   const Field& field_;
   DISALLOW_COPY_AND_ASSIGN(FieldDependentArray);
 };
 
 
 void Field::RegisterDependentCode(const Code& code) const {
@@ skipping 10 matching lines @@
   ASSERT(IsOriginal());
   FieldDependentArray a(*this);
   a.DisableCode();
 }
 
 
 bool Field::IsConsistentWith(const Field& other) const {
   return (raw_ptr()->guarded_cid_ == other.raw_ptr()->guarded_cid_) &&
          (raw_ptr()->is_nullable_ == other.raw_ptr()->is_nullable_) &&
          (raw_ptr()->guarded_list_length_ ==
-             other.raw_ptr()->guarded_list_length_) &&
+          other.raw_ptr()->guarded_list_length_) &&
          (is_unboxing_candidate() == other.is_unboxing_candidate());
 }
 
 
 bool Field::IsUninitialized() const {
   const Instance& value = Instance::Handle(raw_ptr()->value_.static_value_);
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
 
@@ skipping 85 matching lines @@
 }
 
 
 const char* Field::GuardedPropertiesAsCString() const {
   if (guarded_cid() == kIllegalCid) {
     return "<?>";
   } else if (guarded_cid() == kDynamicCid) {
     return "<*>";
   }
 
-  const Class& cls = Class::Handle(
-      Isolate::Current()->class_table()->At(guarded_cid()));
+  const Class& cls =
+      Class::Handle(Isolate::Current()->class_table()->At(guarded_cid()));
   const char* class_name = String::Handle(cls.Name()).ToCString();
 
-  if (RawObject::IsBuiltinListClassId(guarded_cid()) &&
-      !is_nullable() &&
+  if (RawObject::IsBuiltinListClassId(guarded_cid()) && !is_nullable() &&
       is_final()) {
     ASSERT(guarded_list_length() != kUnknownFixedLength);
     if (guarded_list_length() == kNoFixedLength) {
-      return Thread::Current()->zone()->PrintToString(
-          "<%s [*]>", class_name);
+      return Thread::Current()->zone()->PrintToString("<%s [*]>", class_name);
     } else {
       return Thread::Current()->zone()->PrintToString(
-          "<%s [%" Pd " @%" Pd "]>",
-          class_name,
-          guarded_list_length(),
+          "<%s [%" Pd " @%" Pd "]>", class_name, guarded_list_length(),
           guarded_list_length_in_object_offset());
     }
   }
 
-  return Thread::Current()->zone()->PrintToString("<%s %s>",
-    is_nullable() ? "nullable" : "not-nullable",
-    class_name);
+  return Thread::Current()->zone()->PrintToString(
+      "<%s %s>", is_nullable() ? "nullable" : "not-nullable", class_name);
 }
 
 
 bool Field::IsExternalizableCid(intptr_t cid) {
   if (FLAG_support_externalizable_strings) {
     return (cid == kOneByteStringCid) || (cid == kTwoByteStringCid);
   } else {
     return false;
   }
 }
@@ skipping 80 matching lines @@
 }
 
 
 void Field::RecordStore(const Object& value) const {
   ASSERT(IsOriginal());
   if (!FLAG_use_field_guards) {
     return;
   }
 
   if (FLAG_trace_field_guards) {
-    THR_Print("Store %s %s <- %s\n",
-              ToCString(),
-              GuardedPropertiesAsCString(),
+    THR_Print("Store %s %s <- %s\n", ToCString(), GuardedPropertiesAsCString(),
               value.ToCString());
   }
 
   if (UpdateGuardedCidAndLength(value)) {
     if (FLAG_trace_field_guards) {
       THR_Print("    => %s\n", GuardedPropertiesAsCString());
     }
 
     DeoptimizeDependentCode();
   }
@@ skipping 18 matching lines @@
 
 
 void LiteralToken::set_value(const Object& value) const {
   StorePointer(&raw_ptr()->value_, value.raw());
 }
 
 
 RawLiteralToken* LiteralToken::New() {
   ASSERT(Object::literal_token_class() != Class::null());
   RawObject* raw = Object::Allocate(LiteralToken::kClassId,
-                                    LiteralToken::InstanceSize(),
-                                    Heap::kOld);
+                                    LiteralToken::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
   if (kind == Token::kINTEGER) {
     const Integer& value = Integer::Handle(Integer::NewCanonical(literal));
@@ skipping 31 matching lines @@
 }
 
 
 void TokenStream::SetStream(const ExternalTypedData& value) const {
   StorePointer(&raw_ptr()->stream_, value.raw());
 }
 
 
 void TokenStream::DataFinalizer(void* isolate_callback_data,
                                 Dart_WeakPersistentHandle handle,
-                                void *peer) {
+                                void* peer) {
   ASSERT(peer != NULL);
   ::free(peer);
 }
 
 
 RawString* TokenStream::PrivateKey() const {
   return raw_ptr()->private_key_;
 }
 
 
 void TokenStream::SetPrivateKey(const String& value) const {
   StorePointer(&raw_ptr()->private_key_, value.raw());
 }
 
 RawString* TokenStream::GenerateSource() const {
-  return GenerateSource(TokenPosition::kMinSource,
-                        TokenPosition::kMaxSource);
+  return GenerateSource(TokenPosition::kMinSource, TokenPosition::kMaxSource);
 }
 
 RawString* TokenStream::GenerateSource(TokenPosition start_pos,
                                        TokenPosition end_pos) const {
   Zone* zone = Thread::Current()->zone();
   Iterator iterator(zone, *this, start_pos, Iterator::kAllTokens);
   const ExternalTypedData& data = ExternalTypedData::Handle(zone, GetStream());
-  const GrowableObjectArray& literals =
-      GrowableObjectArray::Handle(zone,
-                                  GrowableObjectArray::New(data.Length()));
+  const GrowableObjectArray& literals = GrowableObjectArray::Handle(
+      zone, GrowableObjectArray::New(data.Length()));
   const String& private_key = String::Handle(zone, PrivateKey());
   intptr_t private_len = private_key.Length();
 
   Token::Kind curr = iterator.CurrentTokenKind();
   Token::Kind prev = Token::kILLEGAL;
   // Handles used in the loop.
   Object& obj = Object::Handle(zone);
   String& literal = String::Handle(zone);
   // Current indentation level.
   int indent = 0;
@@ skipping 117 matching lines @@
         // Do nothing.
         break;
     }
 
     // Update the few cases where both tokens need to be taken into account.
     if (((curr == Token::kIF) || (curr == Token::kFOR)) &&
         (next == Token::kLPAREN)) {
       separator = &Symbols::Blank();
     } else if ((curr == Token::kASSIGN) && (next == Token::kLPAREN)) {
       separator = &Symbols::Blank();
-    } else if ((curr == Token::kRETURN  ||
-                curr == Token::kCONDITIONAL ||
+    } else if ((curr == Token::kRETURN || curr == Token::kCONDITIONAL ||
                 Token::IsBinaryOperator(curr) ||
-                Token::IsEqualityOperator(curr)) && (next == Token::kLPAREN)) {
+                Token::IsEqualityOperator(curr)) &&
+               (next == Token::kLPAREN)) {
       separator = &Symbols::Blank();
     } else if ((curr == Token::kLBRACE) && (next == Token::kRBRACE)) {
       separator = NULL;
     } else if ((curr == Token::kSEMICOLON) && (next != Token::kNEWLINE)) {
       separator = &Symbols::Blank();
     } else if ((curr == Token::kIS) && (next == Token::kNOT)) {
       separator = NULL;
     } else if ((prev == Token::kIS) && (curr == Token::kNOT)) {
       separator = &Symbols::Blank();
     } else if ((curr == Token::kIDENT) &&
                ((next == Token::kINCR) || (next == Token::kDECR))) {
       separator = NULL;
     } else if (((curr == Token::kINCR) || (curr == Token::kDECR)) &&
                (next == Token::kIDENT)) {
       separator = NULL;
     }
 
     // Add the separator.
     if (separator != NULL) {
       literals.Add(*separator);
     }
 
     // Account for indentation in case we printed a newline.
     if (curr == Token::kNEWLINE) {
-        for (int i = 0; i < indent; i++) {
-          literals.Add(Symbols::TwoSpaces());
-        }
+      for (int i = 0; i < indent; i++) {
+        literals.Add(Symbols::TwoSpaces());
+      }
     }
 
     // Setup for next iteration.
     prev = curr;
     curr = next;
   }
   const Array& source = Array::Handle(Array::MakeArray(literals));
   return String::ConcatAll(source);
 }
 
 
 intptr_t TokenStream::ComputeSourcePosition(TokenPosition tok_pos) const {
   Zone* zone = Thread::Current()->zone();
-  Iterator iterator(zone,
-                    *this,
-                    TokenPosition::kMinSource,
+  Iterator iterator(zone, *this, TokenPosition::kMinSource,
                     Iterator::kAllTokens);
   intptr_t src_pos = 0;
   Token::Kind kind = iterator.CurrentTokenKind();
   while ((iterator.CurrentPosition() < tok_pos) && (kind != Token::kEOS)) {
     iterator.Advance();
     kind = iterator.CurrentTokenKind();
     src_pos++;
   }
   return src_pos;
 }
 
 
 RawTokenStream* TokenStream::New() {
   ASSERT(Object::token_stream_class() != Class::null());
   RawObject* raw = Object::Allocate(TokenStream::kClassId,
-                                    TokenStream::InstanceSize(),
-                                    Heap::kOld);
+                                    TokenStream::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawTokenStream*>(raw);
 }
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TokenStream::New: invalid len %" Pd "\n", len);
   }
   uint8_t* data = reinterpret_cast<uint8_t*>(::malloc(len));
   ASSERT(data != NULL);
   Zone* zone = Thread::Current()->zone();
   const ExternalTypedData& stream = ExternalTypedData::Handle(
-      zone,
-      ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
-                             data, len, Heap::kOld));
+      zone, ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, data, len,
+                                   Heap::kOld));
   stream.AddFinalizer(data, DataFinalizer, len);
   const TokenStream& result = TokenStream::Handle(zone, TokenStream::New());
   result.SetStream(stream);
   return result.raw();
 }
 
 
 // CompressedTokenMap maps String and LiteralToken keys to Smi values.
 // It also supports lookup by TokenDescriptor.
 class CompressedTokenTraits {
@@ skipping 31 matching lines @@
 typedef UnorderedHashMap<CompressedTokenTraits> CompressedTokenMap;
 
 
 // Helper class for creation of compressed token stream data.
 class CompressedTokenStreamData : public Scanner::TokenCollector {
  public:
   static const intptr_t kInitialBufferSize = 16 * KB;
   static const bool kPrintTokenObjects = false;
 
   CompressedTokenStreamData(const GrowableObjectArray& ta,
-                            CompressedTokenMap* map) :
-      buffer_(NULL),
-      stream_(&buffer_, Reallocate, kInitialBufferSize),
-      token_objects_(ta),
-      tokens_(map),
-      value_(Object::Handle()),
-      fresh_index_smi_(Smi::Handle()),
-      num_tokens_collected_(0) {
-  }
-  virtual ~CompressedTokenStreamData() { }
+                            CompressedTokenMap* map)
+      : buffer_(NULL),
+        stream_(&buffer_, Reallocate, kInitialBufferSize),
+        token_objects_(ta),
+        tokens_(map),
+        value_(Object::Handle()),
+        fresh_index_smi_(Smi::Handle()),
+        num_tokens_collected_(0) {}
+  virtual ~CompressedTokenStreamData() {}
 
   virtual void AddToken(const Scanner::TokenDescriptor& token) {
     if (token.kind == Token::kIDENT) {  // Identifier token.
       AddIdentToken(*token.literal);
     } else if (Token::NeedsLiteralToken(token.kind)) {  // Literal token.
       AddLiteralToken(token);
     } else {  // Keyword, pseudo keyword etc.
       ASSERT(token.kind < Token::kNumTokens);
       AddSimpleToken(token.kind);
     }
     num_tokens_collected_++;
   }
 
   // Return the compressed token stream.
   uint8_t* GetStream() const { return buffer_; }
 
   // Return the compressed token stream length.
   intptr_t Length() const { return stream_.bytes_written(); }
 
   intptr_t NumTokens() const { return num_tokens_collected_; }
 
  private:
   // Add an IDENT token into the stream and the token hash map.
   void AddIdentToken(const String& ident) {
     ASSERT(ident.IsSymbol());
     const intptr_t fresh_index = token_objects_.Length();
     fresh_index_smi_ = Smi::New(fresh_index);
-    intptr_t index = Smi::Value(Smi::RawCast(
-        tokens_->InsertOrGetValue(ident, fresh_index_smi_)));
+    intptr_t index = Smi::Value(
+        Smi::RawCast(tokens_->InsertOrGetValue(ident, fresh_index_smi_)));
     if (index == fresh_index) {
       token_objects_.Add(ident);
       if (kPrintTokenObjects) {
         int iid = Isolate::Current()->main_port() % 1024;
-        OS::Print("ident  %03x  %p <%s>\n",
-                  iid, ident.raw(), ident.ToCString());
+        OS::Print("ident  %03x  %p <%s>\n", iid, ident.raw(),
+                  ident.ToCString());
       }
     }
     WriteIndex(index);
   }
 
   // Add a LITERAL token into the stream and the token hash map.
   void AddLiteralToken(const Scanner::TokenDescriptor& descriptor) {
     ASSERT(descriptor.literal->IsSymbol());
     bool is_present = false;
     value_ = tokens_->GetOrNull(descriptor, &is_present);
     intptr_t index = -1;
     if (is_present) {
       ASSERT(value_.IsSmi());
       index = Smi::Cast(value_).Value();
     } else {
       const intptr_t fresh_index = token_objects_.Length();
       fresh_index_smi_ = Smi::New(fresh_index);
       const LiteralToken& lit = LiteralToken::Handle(
           LiteralToken::New(descriptor.kind, *descriptor.literal));
-      index = Smi::Value(Smi::RawCast(
-          tokens_->InsertOrGetValue(lit, fresh_index_smi_)));
+      index = Smi::Value(
+          Smi::RawCast(tokens_->InsertOrGetValue(lit, fresh_index_smi_)));
       token_objects_.Add(lit);
       if (kPrintTokenObjects) {
         int iid = Isolate::Current()->main_port() % 1024;
-        printf("lit    %03x  %p  %p  %p  <%s>\n",
-               iid, token_objects_.raw(), lit.literal(), lit.value(),
+        printf("lit    %03x  %p  %p  %p  <%s>\n", iid, token_objects_.raw(),
+               lit.literal(), lit.value(),
                String::Handle(lit.literal()).ToCString());
       }
     }
     WriteIndex(index);
   }
 
   // Add a simple token into the stream.
-  void AddSimpleToken(intptr_t kind) {
-    stream_.WriteUnsigned(kind);
-  }
+  void AddSimpleToken(intptr_t kind) { stream_.WriteUnsigned(kind); }
 
   void WriteIndex(intptr_t value) {
     stream_.WriteUnsigned(value + Token::kNumTokens);
   }
 
   static uint8_t* Reallocate(uint8_t* ptr,
                              intptr_t old_size,
                              intptr_t new_size) {
     void* new_ptr = ::realloc(reinterpret_cast<void*>(ptr), new_size);
     return reinterpret_cast<uint8_t*>(new_ptr);
@@ skipping 26 matching lines @@
     if (store->token_objects() == GrowableObjectArray::null()) {
       OpenSharedTokenList(thread->isolate());
     }
     token_objects = store->token_objects();
     token_objects_map = store->token_objects_map();
   } else {
     // Use new, non-shared token array.
     const int kInitialPrivateCapacity = 256;
     token_objects =
         GrowableObjectArray::New(kInitialPrivateCapacity, Heap::kOld);
-    token_objects_map =
-        HashTables::New<CompressedTokenMap>(kInitialPrivateCapacity,
-                                            Heap::kOld);
+    token_objects_map = HashTables::New<CompressedTokenMap>(
+        kInitialPrivateCapacity, Heap::kOld);
   }
   CompressedTokenMap map(token_objects_map.raw());
   CompressedTokenStreamData data(token_objects, &map);
   Scanner scanner(source, private_key);
   scanner.ScanAll(&data);
   INC_STAT(thread, num_tokens_scanned, data.NumTokens());
 
   // Create and setup the token stream object.
   const ExternalTypedData& stream = ExternalTypedData::Handle(
       zone,
-      ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
-                             data.GetStream(), data.Length(), Heap::kOld));
+      ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, data.GetStream(),
+                             data.Length(), Heap::kOld));
   intptr_t external_size = data.Length();
   stream.AddFinalizer(data.GetStream(), DataFinalizer, external_size);
   const TokenStream& result = TokenStream::Handle(zone, New());
   result.SetPrivateKey(private_key);
   {
     NoSafepointScope no_safepoint;
     result.SetStream(stream);
     result.SetTokenObjects(token_objects);
   }
 
   token_objects_map = map.Release().raw();
   if (use_shared_tokens) {
     thread->isolate()->object_store()->set_token_objects_map(token_objects_map);
   }
   return result.raw();
 }
 
 
 void TokenStream::OpenSharedTokenList(Isolate* isolate) {
-  const int kInitialSharedCapacity = 5*1024;
+  const int kInitialSharedCapacity = 5 * 1024;
   ObjectStore* store = isolate->object_store();
   ASSERT(store->token_objects() == GrowableObjectArray::null());
   const GrowableObjectArray& token_objects = GrowableObjectArray::Handle(
       GrowableObjectArray::New(kInitialSharedCapacity, Heap::kOld));
   store->set_token_objects(token_objects);
   const Array& token_objects_map = Array::Handle(
-      HashTables::New<CompressedTokenMap>(kInitialSharedCapacity,
-                                          Heap::kOld));
+      HashTables::New<CompressedTokenMap>(kInitialSharedCapacity, Heap::kOld));
   store->set_token_objects_map(token_objects_map);
 }
 
 
 void TokenStream::CloseSharedTokenList(Isolate* isolate) {
   isolate->object_store()->set_token_objects(GrowableObjectArray::Handle());
   isolate->object_store()->set_token_objects_map(Array::null_array());
 }
 
 
 const char* TokenStream::ToCString() const {
   return "TokenStream";
 }
 
 
 TokenStream::Iterator::Iterator(Zone* zone,
                                 const TokenStream& tokens,
                                 TokenPosition token_pos,
                                 Iterator::StreamType stream_type)
     : tokens_(TokenStream::Handle(zone, tokens.raw())),
       data_(ExternalTypedData::Handle(zone, tokens.GetStream())),
       stream_(reinterpret_cast<uint8_t*>(data_.DataAddr(0)), data_.Length()),
-      token_objects_(Array::Handle(zone,
-         GrowableObjectArray::Handle(zone, tokens.TokenObjects()).data())),
+      token_objects_(Array::Handle(
+          zone,
+          GrowableObjectArray::Handle(zone, tokens.TokenObjects()).data())),
       obj_(Object::Handle(zone)),
       cur_token_pos_(token_pos.Pos()),
       cur_token_kind_(Token::kILLEGAL),
       cur_token_obj_index_(-1),
       stream_type_(stream_type) {
   ASSERT(token_pos != TokenPosition::kNoSource);
   if (token_pos.IsReal()) {
     SetCurrentPosition(token_pos);
   }
 }
@@ skipping 148 matching lines @@
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& info =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   const String& source = String::Handle(zone, Source());
   const String& key = Symbols::Empty();
   const Object& line_separator = Object::Handle(zone);
   const TokenStream& tkns = TokenStream::Handle(zone, tokens());
   Smi& value = Smi::Handle(zone);
   String& tokenValue = String::Handle(zone);
   ASSERT(!tkns.IsNull());
-  TokenStream::Iterator tkit(zone,
-                             tkns,
-                             TokenPosition::kMinSource,
+  TokenStream::Iterator tkit(zone, tkns, TokenPosition::kMinSource,
                              TokenStream::Iterator::kAllTokens);
   int current_line = -1;
   Scanner s(source, key);
   s.Scan();
   bool skippedNewline = false;
   while (tkit.CurrentTokenKind() != Token::kEOS) {
     if (tkit.CurrentTokenKind() == Token::kNEWLINE) {
       // Skip newlines from the token stream.
       skippedNewline = true;
       tkit.Advance();
@@ skipping 101 matching lines @@
 void Script::set_load_timestamp(int64_t value) const {
   StoreNonPointer(&raw_ptr()->load_timestamp_, value);
 }
 
 
 void Script::set_tokens(const TokenStream& value) const {
   StorePointer(&raw_ptr()->tokens_, value.raw());
 }
 
 
-void Script::Tokenize(const String& private_key,
-                      bool use_shared_tokens) const {
+void Script::Tokenize(const String& private_key, bool use_shared_tokens) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const TokenStream& tkns = TokenStream::Handle(zone, tokens());
   if (!tkns.IsNull()) {
     // Already tokenized.
     return;
   }
   // Get the source, scan and allocate the token stream.
   VMTagScope tagScope(thread, VMTag::kCompileScannerTagId);
   CSTAT_TIMER_SCOPE(thread, scanner_timer);
   const String& src = String::Handle(zone, Source());
-  const TokenStream& ts = TokenStream::Handle(zone,
-      TokenStream::New(src, private_key, use_shared_tokens));
+  const TokenStream& ts = TokenStream::Handle(
+      zone, TokenStream::New(src, private_key, use_shared_tokens));
   set_tokens(ts);
   INC_STAT(thread, src_length, src.Length());
 }
 
 
 void Script::SetLocationOffset(intptr_t line_offset,
                                intptr_t col_offset) const {
   ASSERT(line_offset >= 0);
   ASSERT(col_offset >= 0);
   StoreNonPointer(&raw_ptr()->line_offset_, line_offset);
@@ skipping 13 matching lines @@
     *line = -1;
     if (column != NULL) {
       *column = -1;
     }
     if (token_len != NULL) {
       *token_len = 1;
     }
     return;
   }
   if (column == NULL) {
-    TokenStream::Iterator tkit(zone,
-                               tkns,
-                               TokenPosition::kMinSource,
+    TokenStream::Iterator tkit(zone, tkns, TokenPosition::kMinSource,
                                TokenStream::Iterator::kAllTokens);
     intptr_t cur_line = line_offset() + 1;
     while ((tkit.CurrentPosition() < token_pos) &&
            (tkit.CurrentTokenKind() != Token::kEOS)) {
       if (tkit.CurrentTokenKind() == Token::kNEWLINE) {
         cur_line++;
       }
       tkit.Advance();
     }
     *line = cur_line;
@@ skipping 24 matching lines @@
                               TokenPosition* first_token_index,
                               TokenPosition* last_token_index) const {
   ASSERT(first_token_index != NULL && last_token_index != NULL);
   ASSERT(line_number > 0);
   Zone* zone = Thread::Current()->zone();
   *first_token_index = TokenPosition::kNoSource;
   *last_token_index = TokenPosition::kNoSource;
   const TokenStream& tkns = TokenStream::Handle(zone, tokens());
   line_number -= line_offset();
   if (line_number < 1) line_number = 1;
-  TokenStream::Iterator tkit(zone,
-                             tkns,
-                             TokenPosition::kMinSource,
+  TokenStream::Iterator tkit(zone, tkns, TokenPosition::kMinSource,
                              TokenStream::Iterator::kAllTokens);
   // Scan through the token stream to the required line.
   intptr_t cur_line = 1;
   while (cur_line < line_number && tkit.CurrentTokenKind() != Token::kEOS) {
     if (tkit.CurrentTokenKind() == Token::kNEWLINE) {
       cur_line++;
     }
     tkit.Advance();
   }
   if (tkit.CurrentTokenKind() == Token::kEOS) {
@@ skipping 29 matching lines @@
   const String& src = String::Handle(Source());
   if (src.IsNull()) {
     ASSERT(Dart::snapshot_kind() == Snapshot::kAppNoJIT);
     return Symbols::OptimizedOut().raw();
   }
   intptr_t relative_line_number = line_number - line_offset();
   intptr_t current_line = 1;
   intptr_t line_start_idx = -1;
   intptr_t last_char_idx = -1;
   for (intptr_t ix = 0;
-       (ix < src.Length()) && (current_line <= relative_line_number);
-       ix++) {
+       (ix < src.Length()) && (current_line <= relative_line_number); ix++) {
     if ((current_line == relative_line_number) && (line_start_idx < 0)) {
       line_start_idx = ix;
     }
     if (src.CharAt(ix) == '\n') {
       current_line++;
     } else if (src.CharAt(ix) == '\r') {
       if ((ix + 1 != src.Length()) && (src.CharAt(ix + 1) != '\n')) {
         current_line++;
       }
     } else {
       last_char_idx = ix;
     }
   }
   // Guarantee that returned string is never NULL.
 
   if (line_start_idx >= 0) {
-    return String::SubString(src,
-                             line_start_idx,
-                             last_char_idx - line_start_idx + 1,
-                             space);
+    return String::SubString(src, line_start_idx,
+                             last_char_idx - line_start_idx + 1, space);
   } else {
     return Symbols::Empty().raw();
   }
 }
 
 
 RawString* Script::GetSnippet(intptr_t from_line,
                               intptr_t from_column,
                               intptr_t to_line,
                               intptr_t to_column) const {
@@ skipping 43 matching lines @@
   if ((snippet_start != -1) && (snippet_end != -1)) {
     snippet =
         String::SubString(src, snippet_start, snippet_end - snippet_start);
   }
   return snippet.raw();
 }
 
 
 RawScript* Script::New() {
   ASSERT(Object::script_class() != Class::null());
-  RawObject* raw = Object::Allocate(Script::kClassId,
-                                    Script::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw =
+      Object::Allocate(Script::kClassId, Script::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawScript*>(raw);
 }
 
 
 RawScript* Script::New(const String& url,
                        const String& source,
                        RawScript::Kind kind) {
   return Script::New(url, url, source, kind);
 }
 
 
 RawScript* Script::New(const String& url,
                        const String& resolved_url,
                        const String& source,
                        RawScript::Kind kind) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Script& result = Script::Handle(zone, Script::New());
   result.set_url(String::Handle(zone, Symbols::New(thread, url)));
   result.set_resolved_url(
       String::Handle(zone, Symbols::New(thread, resolved_url)));
   result.set_source(source);
   result.set_kind(kind);
-  result.set_load_timestamp(FLAG_remove_script_timestamps_for_test
-                            ? 0 : OS::GetCurrentTimeMillis());
+  result.set_load_timestamp(
+      FLAG_remove_script_timestamps_for_test ? 0 : OS::GetCurrentTimeMillis());
   result.SetLocationOffset(0, 0);
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   const String& name = String::Handle(url());
   return OS::SCreate(Thread::Current()->zone(), "Script(%s)", name.ToCString());
 }
 
 
 RawLibrary* Script::FindLibrary() const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
-  const GrowableObjectArray& libs = GrowableObjectArray::Handle(zone,
-      isolate->object_store()->libraries());
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
   Library& lib = Library::Handle(zone);
   Array& scripts = Array::Handle(zone);
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     scripts = lib.LoadedScripts();
     for (intptr_t j = 0; j < scripts.Length(); j++) {
       if (scripts.At(j) == raw()) {
         return lib.raw();
       }
     }
@@ skipping 25 matching lines @@
   while (obj.IsNull() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
 }
 
 
 ClassDictionaryIterator::ClassDictionaryIterator(const Library& library,
                                                  IterationKind kind)
     : DictionaryIterator(library),
-      toplevel_class_(Class::Handle(
-          (kind == kIteratePrivate)
-              ? library.toplevel_class()
-              : Class::null())) {
+      toplevel_class_(Class::Handle((kind == kIteratePrivate)
+                                        ? library.toplevel_class()
+                                        : Class::null())) {
   MoveToNextClass();
 }
 
 
 RawClass* ClassDictionaryIterator::GetNextClass() {
   ASSERT(HasNext());
   Class& cls = Class::Handle();
   if (next_ix_ < size_) {
     int ix = next_ix_++;
     cls ^= array_.At(ix);
@@ skipping 38 matching lines @@
   Object& obj = Object::Handle(array_.At(next_ix_));
   while (!obj.IsLibraryPrefix() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
 }
 
 
 static void ReportTooManyImports(const Library& lib) {
   const String& url = String::Handle(lib.url());
-  Report::MessageF(Report::kError,
-                   Script::Handle(lib.LookupScript(url)),
-                   TokenPosition::kNoSource,
-                   Report::AtLocation,
-                   "too many imports in library '%s'",
-                   url.ToCString());
+  Report::MessageF(Report::kError, Script::Handle(lib.LookupScript(url)),
+                   TokenPosition::kNoSource, Report::AtLocation,
+                   "too many imports in library '%s'", url.ToCString());
   UNREACHABLE();
 }
 
 
 void Library::set_num_imports(intptr_t value) const {
   if (!Utils::IsUint(16, value)) {
     ReportTooManyImports(*this);
   }
   StoreNonPointer(&raw_ptr()->num_imports_, value);
 }
@@ skipping 41 matching lines @@
  public:
   static const char* Name() { return "LibraryUrlTraits"; }
   static bool ReportStats() { return false; }
 
   // Called when growing the table.
   static bool IsMatch(const Object& a, const Object& b) {
     ASSERT(a.IsLibrary() && b.IsLibrary());
     // Library objects are always canonical.
     return a.raw() == b.raw();
   }
-  static uword Hash(const Object& key) {
-    return Library::Cast(key).UrlHash();
-  }
+  static uword Hash(const Object& key) { return Library::Cast(key).UrlHash(); }
 };
 typedef UnorderedHashSet<LibraryUrlTraits> LibraryLoadErrorSet;
 
 
 RawInstance* Library::TransitiveLoadError() const {
   if (LoadError() != Instance::null()) {
     return LoadError();
   }
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
@@ skipping 63 matching lines @@
   if (i == num_classes) return;
   // Replace the entry with the script. We keep the script so that
   // Library::LoadedScripts() can find it without having to iterate
   // over the members of each class.
   ASSERT(i < num_classes);  // We must have found a class.
   const Script& patch_script = Script::Handle(cls.script());
   patch_classes.SetAt(i, patch_script);
 }
 
 
-static RawString* MakeClassMetaName(Thread* thread, Zone* zone,
+static RawString* MakeClassMetaName(Thread* thread,
+                                    Zone* zone,
                                     const Class& cls) {
-  return Symbols::FromConcat(thread,
-                             Symbols::At(), String::Handle(zone, cls.Name()));
+  return Symbols::FromConcat(thread, Symbols::At(),
+                             String::Handle(zone, cls.Name()));
 }
 
 
-static RawString* MakeFieldMetaName(Thread* thread, Zone* zone,
+static RawString* MakeFieldMetaName(Thread* thread,
+                                    Zone* zone,
                                     const Field& field) {
-  const String& cname = String::Handle(zone,
+  const String& cname = String::Handle(
+      zone,
       MakeClassMetaName(thread, zone, Class::Handle(zone, field.Origin())));
   GrowableHandlePtrArray<const String> pieces(zone, 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
   pieces.Add(String::Handle(field.name()));
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
-static RawString* MakeFunctionMetaName(Thread* thread, Zone* zone,
+static RawString* MakeFunctionMetaName(Thread* thread,
+                                       Zone* zone,
                                        const Function& func) {
-  const String& cname = String::Handle(zone,
+  const String& cname = String::Handle(
+      zone,
       MakeClassMetaName(thread, zone, Class::Handle(zone, func.origin())));
   GrowableHandlePtrArray<const String> pieces(zone, 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
   pieces.Add(String::Handle(func.QualifiedScrubbedName()));
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
-static RawString* MakeTypeParameterMetaName(Thread* thread, Zone* zone,
+static RawString* MakeTypeParameterMetaName(Thread* thread,
+                                            Zone* zone,
                                             const TypeParameter& param) {
-  const String& cname = String::Handle(zone,
+  const String& cname = String::Handle(
+      zone,
       MakeClassMetaName(thread, zone,
                         Class::Handle(zone, param.parameterized_class())));
   GrowableHandlePtrArray<const String> pieces(zone, 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
   pieces.Add(String::Handle(param.name()));
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 void Library::AddMetadata(const Object& owner,
                           const String& name,
                           TokenPosition token_pos) const {
   Thread* thread = Thread::Current();
   ASSERT(thread->IsMutatorThread());
   Zone* zone = thread->zone();
   const String& metaname = String::Handle(zone, Symbols::New(thread, name));
-  const Field& field = Field::Handle(zone,
-      Field::NewTopLevel(metaname,
-                         false,  // is_final
-                         false,  // is_const
-                         owner,
-                         token_pos));
+  const Field& field =
+      Field::Handle(zone, Field::NewTopLevel(metaname,
+                                             false,  // is_final
+                                             false,  // is_const
+                                             owner, token_pos));
   field.SetFieldType(Object::dynamic_type());
   field.set_is_reflectable(false);
   field.SetStaticValue(Array::empty_array(), true);
   GrowableObjectArray& metadata =
       GrowableObjectArray::Handle(zone, this->metadata());
   metadata.Add(field, Heap::kOld);
 }
 
 
 void Library::AddClassMetadata(const Class& cls,
@@ skipping 26 matching lines @@
   AddMetadata(Object::Handle(zone, func.RawOwner()),
               String::Handle(zone, MakeFunctionMetaName(thread, zone, func)),
               token_pos);
 }
 
 
 void Library::AddTypeParameterMetadata(const TypeParameter& param,
                                        TokenPosition token_pos) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  AddMetadata(Class::Handle(zone, param.parameterized_class()),
-              String::Handle(zone,
-                             MakeTypeParameterMetaName(thread, zone, param)),
-              token_pos);
+  AddMetadata(
+      Class::Handle(zone, param.parameterized_class()),
+      String::Handle(zone, MakeTypeParameterMetaName(thread, zone, param)),
+      token_pos);
 }
 
 
 void Library::AddLibraryMetadata(const Object& tl_owner,
                                  TokenPosition token_pos) const {
   AddMetadata(tl_owner, Symbols::TopLevel(), token_pos);
 }
 
 
 RawString* Library::MakeMetadataName(const Object& obj) const {
@@ skipping 51 matching lines @@
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
       field.SetStaticValue(Array::Cast(metadata), true);
     }
   }
   return metadata.raw();
 }
 
 
 static bool ShouldBePrivate(const String& name) {
-  return
-      (name.Length() >= 1 && name.CharAt(0) == '_') ||
-      (name.Length() >= 5 &&
-        (name.CharAt(4) == '_' &&
-          (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
-          name.CharAt(1) == 'e' &&
-          name.CharAt(2) == 't' &&
-          name.CharAt(3) == ':'));
+  return (name.Length() >= 1 && name.CharAt(0) == '_') ||
+         (name.Length() >= 5 &&
+          (name.CharAt(4) == '_' &&
+           (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
+           name.CharAt(1) == 'e' && name.CharAt(2) == 't' &&
+           name.CharAt(3) == ':'));
 }
 
 
 RawObject* Library::ResolveName(const String& name) const {
   Object& obj = Object::Handle();
   if (FLAG_use_lib_cache && LookupResolvedNamesCache(name, &obj)) {
     return obj.raw();
   }
   obj = LookupLocalObject(name);
   if (!obj.IsNull()) {
@@ skipping 20 matching lines @@
 
 
 class StringEqualsTraits {
  public:
   static const char* Name() { return "StringEqualsTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     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(); }
 };
 typedef UnorderedHashMap<StringEqualsTraits> ResolvedNamesMap;
 
 
 // Returns true if the name is found in the cache, false no cache hit.
 // obj is set to the cached entry. It may be null, indicating that the
 // name does not resolve to anything in this library.
-bool Library::LookupResolvedNamesCache(const String& name,
-                                       Object* obj) const {
+bool Library::LookupResolvedNamesCache(const String& name, Object* obj) const {
   ResolvedNamesMap cache(resolved_names());
   bool present = false;
   *obj = cache.GetOrNull(name, &present);
-  // Mutator compiler thread may add entries and therefore
-  // change 'resolved_names()' while running a background compilation;
-  // ASSERT that 'resolved_names()' has not changed only in mutator.
+// Mutator compiler thread may add entries and therefore
+// change 'resolved_names()' while running a background compilation;
+// ASSERT that 'resolved_names()' has not changed only in mutator.
 #if defined(DEBUG)
   if (Thread::Current()->IsMutatorThread()) {
     ASSERT(cache.Release().raw() == resolved_names());
   } else {
     // Release must be called in debug mode.
     cache.Release();
   }
 #endif
   return present;
 }
 
 
 // Add a name to the resolved name cache. This name resolves to the
 // given object in this library scope. obj may be null, which means
 // the name does not resolve to anything in this library scope.
 void Library::AddToResolvedNamesCache(const String& name,
                                       const Object& obj) const {
   if (!FLAG_use_lib_cache || Compiler::IsBackgroundCompilation()) {
     return;
   }
   ResolvedNamesMap cache(resolved_names());
   cache.UpdateOrInsert(name, obj);
   StorePointer(&raw_ptr()->resolved_names_, cache.Release().raw());
 }
 
 
-bool Library::LookupExportedNamesCache(const String& name,
-                                       Object* obj) const {
+bool Library::LookupExportedNamesCache(const String& name, Object* obj) const {
   ASSERT(FLAG_use_exp_cache);
   if (exported_names() == Array::null()) {
     return false;
   }
   ResolvedNamesMap cache(exported_names());
   bool present = false;
   *obj = cache.GetOrNull(name, &present);
-  // Mutator compiler thread may add entries and therefore
-  // change 'exported_names()' while running a background compilation;
-  // do not ASSERT that 'exported_names()' has not changed.
+// Mutator compiler thread may add entries and therefore
+// change 'exported_names()' while running a background compilation;
+// do not ASSERT that 'exported_names()' has not changed.
 #if defined(DEBUG)
   if (Thread::Current()->IsMutatorThread()) {
     ASSERT(cache.Release().raw() == exported_names());
   } else {
     // Release must be called in debug mode.
     cache.Release();
   }
 #endif
   return present;
 }
@@ skipping 83 matching lines @@
   // Copy used count.
   new_entry = dict.At(dict_size);
   new_dict.SetAt(new_dict_size, new_entry);
   // Remember the new dictionary now.
   StorePointer(&raw_ptr()->dictionary_, new_dict.raw());
 }
 
 
 void Library::AddObject(const Object& obj, const String& name) const {
   ASSERT(Thread::Current()->IsMutatorThread());
-  ASSERT(obj.IsClass() ||
-         obj.IsFunction() ||
-         obj.IsField() ||
+  ASSERT(obj.IsClass() || obj.IsFunction() || obj.IsField() ||
          obj.IsLibraryPrefix());
   ASSERT(name.Equals(String::Handle(obj.DictionaryName())));
   ASSERT(LookupLocalObject(name) == Object::null());
   const Array& dict = Array::Handle(dictionary());
   intptr_t dict_size = dict.Length() - 1;
   intptr_t index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle();
   entry = dict.At(index);
   // An empty spot will be found because we keep the hash set at most 75% full.
@@ skipping 50 matching lines @@
       // The Lookup call above may return a setter x= when we are looking
       // for the name x. Make sure we only return when a matching name
       // is found.
       String& obj_name = String::Handle(obj.DictionaryName());
       if (Field::IsSetterName(obj_name) == Field::IsSetterName(name)) {
         break;
       }
     }
   }
   bool in_cycle = (trail->RemoveLast() < 0);
-  if (FLAG_use_exp_cache &&
-      !in_cycle &&
-      !Compiler::IsBackgroundCompilation()) {
+  if (FLAG_use_exp_cache && !in_cycle && !Compiler::IsBackgroundCompilation()) {
     AddToExportedNamesCache(name, obj);
   }
   return obj.raw();
 }
 
 
-RawObject* Library::LookupEntry(const String& name, intptr_t *index) const {
+RawObject* Library::LookupEntry(const String& name, intptr_t* index) const {
   Thread* thread = Thread::Current();
   REUSABLE_ARRAY_HANDLESCOPE(thread);
   REUSABLE_OBJECT_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
   Array& dict = thread->ArrayHandle();
   dict ^= dictionary();
   intptr_t dict_size = dict.Length() - 1;
   *index = name.Hash() % dict_size;
   Object& entry = thread->ObjectHandle();
   String& entry_name = thread->StringHandle();
@@ skipping 128 matching lines @@
       }
       AddScriptIfUnique(scripts, owner_script);
     }
 
     // Add all scripts from patch classes.
     GrowableObjectArray& patches = GrowableObjectArray::Handle(patch_classes());
     for (intptr_t i = 0; i < patches.Length(); i++) {
       entry = patches.At(i);
       if (entry.IsClass()) {
         owner_script = Class::Cast(entry).script();
-      }  else {
+      } else {
         ASSERT(entry.IsScript());
         owner_script = Script::Cast(entry).raw();
       }
       AddScriptIfUnique(scripts, owner_script);
     }
 
     cls ^= toplevel_class();
     if (!cls.IsNull()) {
       owner_script = cls.script();
       AddScriptIfUnique(scripts, owner_script);
@@ skipping 33 matching lines @@
   for (int i = 0; i < num_scripts; i++) {
     script ^= scripts.At(i);
     script_url = script.url();
     const intptr_t start_idx = script_url.Length() - url_length;
     if ((start_idx == 0) && url.Equals(script_url)) {
       return script.raw();
     } else if (start_idx > 0) {
       // If we do a suffix match, only match if the partial path
       // starts at or immediately after the path separator.
       if (((url.CharAt(0) == '/') ||
-          (script_url.CharAt(start_idx - 1) == '/')) &&
+           (script_url.CharAt(start_idx - 1) == '/')) &&
           url.Equals(script_url, start_idx, url_length)) {
         return script.raw();
       }
     }
   }
   return Script::null();
 }
 
 
 RawObject* Library::LookupLocalObject(const String& name) const {
@@ skipping 253 matching lines @@
 // non-empty.
 bool Library::HasExports() const {
   return exports() != Object::empty_array().raw();
 }
 
 
 // We add one namespace at a time to the exports array and don't
 // pre-allocate any unused capacity. The assumption is that
 // re-exports are quite rare.
 void Library::AddExport(const Namespace& ns) const {
-  Array &exports = Array::Handle(this->exports());
+  Array& exports = Array::Handle(this->exports());
   intptr_t num_exports = exports.Length();
   exports = Array::Grow(exports, num_exports + 1);
   StorePointer(&raw_ptr()->exports_, exports.raw());
   exports.SetAt(num_exports, ns);
 }
 
 
 static RawArray* NewDictionary(intptr_t initial_size) {
   const Array& dict = Array::Handle(Array::New(initial_size + 1, Heap::kOld));
   // The last element of the dictionary specifies the number of in use slots.
@@ skipping 33 matching lines @@
 void Library::InitImportList() const {
   const Array& imports =
       Array::Handle(Array::New(kInitialImportsCapacity, Heap::kOld));
   StorePointer(&raw_ptr()->imports_, imports.raw());
   StoreNonPointer(&raw_ptr()->num_imports_, 0);
 }
 
 
 RawLibrary* Library::New() {
   ASSERT(Object::library_class() != Class::null());
-  RawObject* raw = Object::Allocate(Library::kClassId,
-                                    Library::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw =
+      Object::Allocate(Library::kClassId, Library::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
-RawLibrary* Library::NewLibraryHelper(const String& url,
-                                      bool import_core_lib) {
+RawLibrary* Library::NewLibraryHelper(const String& url, bool import_core_lib) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(thread->IsMutatorThread());
   // Force the url to have a hash code.
   url.Hash();
   const bool dart_scheme = url.StartsWith(Symbols::DartScheme());
   const bool dart_private_scheme =
       dart_scheme && url.StartsWith(Symbols::DartSchemePrivate());
   const Library& result = Library::Handle(zone, Library::New());
   result.StorePointer(&result.raw_ptr()->name_, Symbols::Empty().raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.StorePointer(&result.raw_ptr()->resolved_names_,
                       Object::empty_array().raw());
-  result.StorePointer(&result.raw_ptr()->exported_names_,
-                      Array::null());
+  result.StorePointer(&result.raw_ptr()->exported_names_, Array::null());
   result.StorePointer(&result.raw_ptr()->dictionary_,
                       Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
   result.StorePointer(&result.raw_ptr()->toplevel_class_, Class::null());
-  result.StorePointer(&result.raw_ptr()->patch_classes_,
-                      GrowableObjectArray::New(Object::empty_array(),
-                                               Heap::kOld));
+  result.StorePointer(
+      &result.raw_ptr()->patch_classes_,
+      GrowableObjectArray::New(Object::empty_array(), Heap::kOld));
   result.StorePointer(&result.raw_ptr()->imports_, Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->exports_, Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->loaded_scripts_, Array::null());
   result.StorePointer(&result.raw_ptr()->load_error_, Instance::null());
   result.set_native_entry_resolver(NULL);
   result.set_native_entry_symbol_resolver(NULL);
   result.set_is_in_fullsnapshot(false);
   result.StoreNonPointer(&result.raw_ptr()->corelib_imported_, true);
   result.set_debuggable(!dart_private_scheme);
   result.set_is_dart_scheme(dart_scheme);
   result.StoreNonPointer(&result.raw_ptr()->load_state_,
                          RawLibrary::kAllocated);
   result.StoreNonPointer(&result.raw_ptr()->index_, -1);
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
   result.InitImportList();
   result.AllocatePrivateKey();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
-    const Namespace& ns = Namespace::Handle(zone,
+    const Namespace& ns = Namespace::Handle(
+        zone,
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     result.AddImport(ns);
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
@@ skipping 28 matching lines @@
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   COMPILE_ASSERT((kNumNativeWrappersClasses > 0) &&
                  (kNumNativeWrappersClasses < 10));
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const String& native_flds_lib_url = Symbols::DartNativeWrappers();
-  const Library& native_flds_lib = Library::Handle(zone,
-      Library::NewLibraryHelper(native_flds_lib_url, false));
+  const Library& native_flds_lib = Library::Handle(
+      zone, Library::NewLibraryHelper(native_flds_lib_url, false));
   const String& native_flds_lib_name = Symbols::DartNativeWrappersLibName();
   native_flds_lib.SetName(native_flds_lib_name);
   native_flds_lib.SetLoadRequested();
   native_flds_lib.Register(thread);
   native_flds_lib.SetLoadInProgress();
   isolate->object_store()->set_native_wrappers_library(native_flds_lib);
   static const char* const kNativeWrappersClass = "NativeFieldWrapperClass";
   static const int kNameLength = 25;
   ASSERT(kNameLength == (strlen(kNativeWrappersClass) + 1 + 1));
   char name_buffer[kNameLength];
   String& cls_name = String::Handle(zone);
   for (int fld_cnt = 1; fld_cnt <= kNumNativeWrappersClasses; fld_cnt++) {
-    OS::SNPrint(name_buffer,
-                kNameLength,
-                "%s%d",
-                kNativeWrappersClass,
+    OS::SNPrint(name_buffer, kNameLength, "%s%d", kNativeWrappersClass,
                 fld_cnt);
     cls_name = Symbols::New(thread, name_buffer);
     Class::NewNativeWrapper(native_flds_lib, cls_name, fld_cnt);
   }
   native_flds_lib.SetLoaded();
 }
 
 
 // LibraryLookupSet maps URIs to libraries.
 class LibraryLookupTraits {
  public:
   static const char* Name() { return "LibraryLookupTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     const String& a_str = String::Cast(a);
     const String& b_str = String::Cast(b);
 
     ASSERT(a_str.HasHash() && b_str.HasHash());
     return a_str.Equals(b_str);
   }
 
-  static uword Hash(const Object& key) {
-    return String::Cast(key).Hash();
-  }
+  static uword Hash(const Object& key) { return String::Cast(key).Hash(); }
 
-  static RawObject* NewKey(const String& str) {
-    return str.raw();
-  }
+  static RawObject* NewKey(const String& str) { return str.raw(); }
 };
 typedef UnorderedHashMap<LibraryLookupTraits> LibraryLookupMap;
 
 
 // Returns library with given url in current isolate, or NULL.
-RawLibrary* Library::LookupLibrary(Thread* thread, const String &url) {
+RawLibrary* Library::LookupLibrary(Thread* thread, const String& url) {
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ObjectStore* object_store = isolate->object_store();
 
   // Make sure the URL string has an associated hash code
   // to speed up the repeated equality checks.
   url.Hash();
 
   // Use the libraries map to lookup the library by URL.
   Library& lib = Library::Handle(zone);
@@ skipping 47 matching lines @@
       return;
     }
   }
 
   // Format of the private key is: "@<sequence number><6 digits of hash>
   const intptr_t hash_mask = 0x7FFFF;
 
   const String& url = String::Handle(zone, this->url());
   intptr_t hash_value = url.Hash() & hash_mask;
 
-  const GrowableObjectArray& libs = GrowableObjectArray::Handle(zone,
-      isolate->object_store()->libraries());
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
   intptr_t sequence_value = libs.Length();
 
   char private_key[32];
-  OS::SNPrint(private_key, sizeof(private_key),
-              "%c%" Pd "%06" Pd "",
+  OS::SNPrint(private_key, sizeof(private_key), "%c%" Pd "%06" Pd "",
               kPrivateKeySeparator, sequence_value, hash_value);
-  const String& key = String::Handle(zone, String::New(private_key,
-                                                       Heap::kOld));
+  const String& key =
+      String::Handle(zone, String::New(private_key, Heap::kOld));
   key.Hash();  // This string may end up in the VM isolate.
   StorePointer(&raw_ptr()->private_key_, key.raw());
 }
 
 
 const String& Library::PrivateCoreLibName(const String& member) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(member));
   return private_name;
 }
 
 
 RawClass* Library::LookupCoreClass(const String& class_name) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
   String& name = String::Handle(zone, class_name.raw());
   if (class_name.CharAt(0) == kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per library basis.
-    name = Symbols::FromConcat(thread,
-        name, String::Handle(zone, core_lib.private_key()));
+    name = Symbols::FromConcat(thread, name,
+                               String::Handle(zone, core_lib.private_key()));
   }
   return core_lib.LookupClass(name);
 }
 
 
 // Cannot handle qualified names properly as it only appends private key to
 // the end (e.g. _Alfa.foo -> _Alfa.foo@...).
 RawString* Library::PrivateName(const String& name) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(IsPrivate(name));
   // ASSERT(strchr(name, '@') == NULL);
   String& str = String::Handle(zone);
   str = name.raw();
-  str = Symbols::FromConcat(thread,
-                            str, String::Handle(zone, this->private_key()));
+  str = Symbols::FromConcat(thread, str,
+                            String::Handle(zone, this->private_key()));
   return str.raw();
 }
 
 
 RawLibrary* Library::GetLibrary(intptr_t index) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
@@ skipping 10 matching lines @@
 void Library::Register(Thread* thread) const {
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ObjectStore* object_store = isolate->object_store();
 
   // A library is "registered" in two places:
   // - A growable array mapping from index to library.
   const String& lib_url = String::Handle(zone, url());
   ASSERT(Library::LookupLibrary(thread, lib_url) == Library::null());
   ASSERT(lib_url.HasHash());
-  GrowableObjectArray& libs = GrowableObjectArray::Handle(zone,
-      object_store->libraries());
+  GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(zone, object_store->libraries());
   ASSERT(!libs.IsNull());
   set_index(libs.Length());
   libs.Add(*this);
 
   // - A map from URL string to library.
   if (object_store->libraries_map() == Array::null()) {
     LibraryLookupMap map(HashTables::New<LibraryLookupMap>(16, Heap::kOld));
     object_store->set_libraries_map(map.Release());
   }
 
@@ skipping 85 matching lines @@
 }
 
 
 RawLibrary* Library::VMServiceLibrary() {
   return Isolate::Current()->object_store()->vmservice_library();
 }
 
 
 const char* Library::ToCString() const {
   const String& name = String::Handle(url());
-  return OS::SCreate(Thread::Current()->zone(),
-      "Library:'%s'", name.ToCString());
+  return OS::SCreate(Thread::Current()->zone(), "Library:'%s'",
+                     name.ToCString());
 }
 
 
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
   }
@@ skipping 177 matching lines @@
     const GrowableObjectArray& pending_deferred_loads =
         GrowableObjectArray::Handle(
             isolate->object_store()->pending_deferred_loads());
     pending_deferred_loads.Add(deferred_lib);
     const String& lib_url = String::Handle(zone, deferred_lib.url());
     Dart_LibraryTagHandler handler = isolate->library_tag_handler();
     Object& obj = Object::Handle(zone);
     {
       TransitionVMToNative transition(thread);
       Api::Scope api_scope(thread);
-      obj = Api::UnwrapHandle(
-              handler(Dart_kImportTag,
-                      Api::NewHandle(thread, importer()),
-                      Api::NewHandle(thread, lib_url.raw())));
+      obj = Api::UnwrapHandle(handler(Dart_kImportTag,
+                                      Api::NewHandle(thread, importer()),
+                                      Api::NewHandle(thread, lib_url.raw())));
     }
     if (obj.IsError()) {
       Exceptions::PropagateError(Error::Cast(obj));
     }
   } else {
     // Another load request is in flight.
     ASSERT(deferred_lib.LoadRequested());
   }
   return false;  // Load request not yet completed.
 }
 
 
 RawArray* LibraryPrefix::dependent_code() const {
   return raw_ptr()->dependent_code_;
 }
 
 
 void LibraryPrefix::set_dependent_code(const Array& array) const {
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
 }
 
 
 class PrefixDependentArray : public WeakCodeReferences {
  public:
   explicit PrefixDependentArray(const LibraryPrefix& prefix)
       : WeakCodeReferences(Array::Handle(prefix.dependent_code())),
-                           prefix_(prefix) {}
+        prefix_(prefix) {}
 
   virtual void UpdateArrayTo(const Array& value) {
     prefix_.set_dependent_code(value);
   }
 
   virtual void ReportDeoptimization(const Code& code) {
     // This gets called when the code object is on the stack
     // while nuking code that depends on a prefix. We don't expect
     // this to happen, so make sure we die loudly if we find
     // ourselves here.
     UNIMPLEMENTED();
   }
 
   virtual void ReportSwitchingCode(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       THR_Print("Prefix '%s': disabling %s code for %s function '%s'\n",
-          String::Handle(prefix_.name()).ToCString(),
-          code.is_optimized() ? "optimized" : "unoptimized",
-          code.IsDisabled() ? "'patched'" : "'unpatched'",
-          Function::Handle(code.function()).ToCString());
+                String::Handle(prefix_.name()).ToCString(),
+                code.is_optimized() ? "optimized" : "unoptimized",
+                code.IsDisabled() ? "'patched'" : "'unpatched'",
+                Function::Handle(code.function()).ToCString());
     }
   }
 
  private:
   const LibraryPrefix& prefix_;
   DISALLOW_COPY_AND_ASSIGN(PrefixDependentArray);
 };
 
 
 void LibraryPrefix::RegisterDependentCode(const Code& code) const {
   ASSERT(is_deferred_load());
   // In background compilation, a library can be loaded while we are compiling.
   // The generated code will be rejected in that case,
   ASSERT(!is_loaded() || Compiler::IsBackgroundCompilation());
   PrefixDependentArray a(*this);
   a.Register(code);
 }
 
 
 void LibraryPrefix::InvalidateDependentCode() const {
   PrefixDependentArray a(*this);
   a.DisableCode();
   set_is_loaded();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
-                                    LibraryPrefix::InstanceSize(),
-                                    Heap::kOld);
+                                    LibraryPrefix::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
                                      const Namespace& import,
                                      bool deferred_load,
                                      const Library& importer) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
@@ skipping 26 matching lines @@
 }
 
 
 void LibraryPrefix::set_importer(const Library& value) const {
   StorePointer(&raw_ptr()->importer_, value.raw());
 }
 
 
 const char* LibraryPrefix::ToCString() const {
   const String& prefix = String::Handle(name());
-  return OS::SCreate(Thread::Current()->zone(),
-      "LibraryPrefix:'%s'", prefix.ToCString());
+  return OS::SCreate(Thread::Current()->zone(), "LibraryPrefix:'%s'",
+                     prefix.ToCString());
 }
 
 
 void Namespace::set_metadata_field(const Field& value) const {
   StorePointer(&raw_ptr()->metadata_field_, value.raw());
 }
 
 
 void Namespace::AddMetadata(const Object& owner, TokenPosition token_pos) {
   ASSERT(Field::Handle(metadata_field()).IsNull());
   Field& field = Field::Handle(Field::NewTopLevel(Symbols::TopLevel(),
                                                   false,  // is_final
                                                   false,  // is_const
-                                                  owner,
-                                                  token_pos));
+                                                  owner, token_pos));
   field.set_is_reflectable(false);
   field.SetFieldType(Object::dynamic_type());
   field.SetStaticValue(Array::empty_array(), true);
   set_metadata_field(field);
 }
 
 
 RawObject* Namespace::GetMetadata() const {
   Field& field = Field::Handle(metadata_field());
   if (field.IsNull()) {
     // There is no metadata for this object.
     return Object::empty_array().raw();
   }
   Object& metadata = Object::Handle();
   metadata = field.StaticValue();
   if (field.StaticValue() == Object::empty_array().raw()) {
     metadata = Parser::ParseMetadata(field);
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
       field.SetStaticValue(Array::Cast(metadata), true);
     }
   }
   return metadata.raw();
 }
 
 
 const char* Namespace::ToCString() const {
   const Library& lib = Library::Handle(library());
-  return OS::SCreate(Thread::Current()->zone(),
-      "Namespace for library '%s'", lib.ToCString());
+  return OS::SCreate(Thread::Current()->zone(), "Namespace for library '%s'",
+                     lib.ToCString());
 }
 
 
 bool Namespace::HidesName(const String& name) const {
   // Quick check for common case with no combinators.
   if (hide_names() == show_names()) {
     ASSERT(hide_names() == Array::null());
     return false;
   }
   const String* plain_name = &name;
@@ skipping 39 matching lines @@
 // names. Also look up getters and setters.
 RawObject* Namespace::Lookup(const String& name,
                              ZoneGrowableArray<intptr_t>* trail) const {
   Zone* zone = Thread::Current()->zone();
   const Library& lib = Library::Handle(zone, library());
 
   if (trail != NULL) {
     // Look for cycle in reexport graph.
     for (int i = 0; i < trail->length(); i++) {
       if (trail->At(i) == lib.index()) {
-        for (int j = i+1; j < trail->length(); j++) {
+        for (int j = i + 1; j < trail->length(); j++) {
           (*trail)[j] = -1;
         }
         return Object::null();
       }
     }
   }
 
   intptr_t ignore = 0;
   // Lookup the name in the library's symbols.
   Object& obj = Object::Handle(zone, lib.LookupEntry(name, &ignore));
-  if (!Field::IsGetterName(name) &&
-      !Field::IsSetterName(name) &&
+  if (!Field::IsGetterName(name) && !Field::IsSetterName(name) &&
       (obj.IsNull() || obj.IsLibraryPrefix())) {
     String& accessor_name = String::Handle(zone);
     accessor_name ^= Field::LookupGetterSymbol(name);
     if (!accessor_name.IsNull()) {
       obj = lib.LookupEntry(accessor_name, &ignore);
     }
     if (obj.IsNull()) {
       accessor_name ^= Field::LookupSetterSymbol(name);
       if (!accessor_name.IsNull()) {
         obj = lib.LookupEntry(accessor_name, &ignore);
@@ skipping 18 matching lines @@
   if (obj.IsNull() || HidesName(name) || obj.IsLibraryPrefix()) {
     return Object::null();
   }
   return obj.raw();
 }
 
 
 RawNamespace* Namespace::New() {
   ASSERT(Object::namespace_class() != Class::null());
   RawObject* raw = Object::Allocate(Namespace::kClassId,
-                                    Namespace::InstanceSize(),
-                                    Heap::kOld);
+                                    Namespace::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawNamespace*>(raw);
 }
 
 
 RawNamespace* Namespace::New(const Library& library,
                              const Array& show_names,
                              const Array& hide_names) {
   ASSERT(show_names.IsNull() || (show_names.Length() > 0));
   ASSERT(hide_names.IsNull() || (hide_names.Length() > 0));
   const Namespace& result = Namespace::Handle(Namespace::New());
@@ skipping 24 matching lines @@
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
 
   // Inner functions get added to the closures array. As part of compilation
   // more closures can be added to the end of the array. Compile all the
   // closures until we have reached the end of the "worklist".
-  const GrowableObjectArray& closures = GrowableObjectArray::Handle(zone,
-      Isolate::Current()->object_store()->closure_functions());
+  const GrowableObjectArray& closures = GrowableObjectArray::Handle(
+      zone, Isolate::Current()->object_store()->closure_functions());
   Function& func = Function::Handle(zone);
   for (int i = 0; i < closures.Length(); i++) {
     func ^= closures.At(i);
     if (!func.HasCode()) {
       error = Compiler::CompileFunction(thread, func);
       if (!error.IsNull()) {
         return error.raw();
       }
       func.ClearICDataArray();
       func.ClearCode();
     }
   }
   return error.raw();
 }
 
 
 RawError* Library::ParseAll(Thread* thread) {
   Zone* zone = thread->zone();
   Error& error = Error::Handle(zone);
   Isolate* isolate = thread->isolate();
-  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
-      isolate->object_store()->libraries());
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(isolate->object_store()->libraries());
   Library& lib = Library::Handle(zone);
   Class& cls = Class::Handle(zone);
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       error = cls.EnsureIsFinalized(thread);
       if (!error.IsNull()) {
         return error.raw();
       }
       error = Compiler::ParseAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
 
   // Inner functions get added to the closures array. As part of compilation
   // more closures can be added to the end of the array. Compile all the
   // closures until we have reached the end of the "worklist".
-  const GrowableObjectArray& closures = GrowableObjectArray::Handle(zone,
-      Isolate::Current()->object_store()->closure_functions());
+  const GrowableObjectArray& closures = GrowableObjectArray::Handle(
+      zone, Isolate::Current()->object_store()->closure_functions());
   Function& func = Function::Handle(zone);
   for (int i = 0; i < closures.Length(); i++) {
     func ^= closures.At(i);
     if (!func.HasCode()) {
       error = Compiler::ParseFunction(thread, func);
       if (!error.IsNull()) {
         return error.raw();
       }
       func.ClearICDataArray();
       func.ClearCode();
@@ skipping 45 matching lines @@
 
 #define CHECK_FINGERPRINTS(class_name, function_name, dest, fp)                \
   func = GetFunction(all_libs, #class_name, #function_name);                   \
   if (func.IsNull()) {                                                         \
     has_errors = true;                                                         \
     OS::Print("Function not found %s.%s\n", #class_name, #function_name);      \
   } else {                                                                     \
     CHECK_FINGERPRINT3(func, class_name, function_name, dest, fp);             \
   }
 
-#define CHECK_FINGERPRINTS2(class_name, function_name, dest, type, fp) \
+#define CHECK_FINGERPRINTS2(class_name, function_name, dest, type, fp)         \
   CHECK_FINGERPRINTS(class_name, function_name, dest, fp)
 
   all_libs.Add(&Library::ZoneHandle(Library::CoreLibrary()));
   CORE_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS2);
   CORE_INTEGER_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS2);
 
   all_libs.Add(&Library::ZoneHandle(Library::MathLibrary()));
   all_libs.Add(&Library::ZoneHandle(Library::TypedDataLibrary()));
   all_libs.Add(&Library::ZoneHandle(Library::CollectionLibrary()));
   all_libs.Add(&Library::ZoneHandle(Library::InternalLibrary()));
@@ skipping 11 matching lines @@
   MATH_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS2);
 
   all_libs.Clear();
   all_libs.Add(&Library::ZoneHandle(Library::TypedDataLibrary()));
   TYPED_DATA_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS2);
 
 #undef CHECK_FINGERPRINTS
 #undef CHECK_FINGERPRINTS2
 
 
-
-Class& cls = Class::Handle();
+  Class& cls = Class::Handle();
 
 #define CHECK_FACTORY_FINGERPRINTS(factory_symbol, cid, fp)                    \
   cls = Isolate::Current()->class_table()->At(cid);                            \
   func = cls.LookupFunctionAllowPrivate(Symbols::factory_symbol());            \
   if (func.IsNull()) {                                                         \
     has_errors = true;                                                         \
     OS::Print("Function not found %s.%s\n", cls.ToCString(),                   \
-        Symbols::factory_symbol().ToCString());                                \
+              Symbols::factory_symbol().ToCString());                          \
   } else {                                                                     \
     CHECK_FINGERPRINT2(func, factory_symbol, cid, fp);                         \
-  }                                                                            \
+  }
 
   RECOGNIZED_LIST_FACTORY_LIST(CHECK_FACTORY_FINGERPRINTS);
 
 #undef CHECK_FACTORY_FINGERPRINTS
 
   if (has_errors) {
     FATAL("Fingerprint mismatch.");
   }
 }
 #endif  // defined(DART_NO_SNAPSHOT) && !defined(PRODUCT).
 
 
 RawInstructions* Instructions::New(intptr_t size, bool has_single_entry_point) {
   ASSERT(size >= 0);
   ASSERT(Object::instructions_class() != Class::null());
   if (size < 0 || size > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Instructions::New: invalid size %" Pd "\n", size);
   }
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
-    RawObject* raw = Object::Allocate(Instructions::kClassId,
-                                      aligned_size,
-                                      Heap::kCode);
+    RawObject* raw =
+        Object::Allocate(Instructions::kClassId, aligned_size, Heap::kCode);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_size(has_single_entry_point ? size : -size);
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
 // Encode integer |value| in SLEB128 format and store into |data|.
-static void EncodeSLEB128(GrowableArray<uint8_t>* data,
-                          intptr_t value) {
+static void EncodeSLEB128(GrowableArray<uint8_t>* data, intptr_t value) {
   bool is_last_part = false;
   while (!is_last_part) {
     uint8_t part = value & 0x7f;
     value >>= 7;
     if ((value == 0 && (part & 0x40) == 0) ||
         (value == static_cast<intptr_t>(-1) && (part & 0x40) != 0)) {
       is_last_part = true;
     } else {
       part |= 0x80;
     }
@@ skipping 40 matching lines @@
 
 RawObjectPool* ObjectPool::New(intptr_t len) {
   ASSERT(Object::object_pool_class() != Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ObjectPool::New: invalid length %" Pd "\n", len);
   }
   ObjectPool& result = ObjectPool::Handle();
   {
     uword size = ObjectPool::InstanceSize(len);
-    RawObject* raw = Object::Allocate(ObjectPool::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw = Object::Allocate(ObjectPool::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
   }
 
   // TODO(fschneider): Compress info array to just use just enough bits for
   // the entry type enum.
   const TypedData& info_array = TypedData::Handle(
       TypedData::New(kTypedDataInt8ArrayCid, len, Heap::kOld));
   result.set_info_array(info_array);
@@ skipping 18 matching lines @@
 }
 
 
 void ObjectPool::DebugPrint() const {
   THR_Print("Object Pool: 0x%" Px "{\n", reinterpret_cast<uword>(raw()));
   for (intptr_t i = 0; i < Length(); i++) {
     intptr_t offset = OffsetFromIndex(i);
     THR_Print("  %" Pd " PP+0x%" Px ": ", i, offset);
     if (InfoAt(i) == kTaggedObject) {
       RawObject* obj = ObjectAt(i);
-      THR_Print("0x%" Px " %s (obj)\n",
-          reinterpret_cast<uword>(obj),
-          Object::Handle(obj).ToCString());
+      THR_Print("0x%" Px " %s (obj)\n", reinterpret_cast<uword>(obj),
+                Object::Handle(obj).ToCString());
     } else if (InfoAt(i) == kNativeEntry) {
       THR_Print("0x%" Px " (native entry)\n", RawValueAt(i));
     } else {
       THR_Print("0x%" Px " (raw)\n", RawValueAt(i));
     }
   }
   THR_Print("}\n");
 }
 
 
@@ skipping 15 matching lines @@
   }
 }
 
 
 RawPcDescriptors* PcDescriptors::New(GrowableArray<uint8_t>* data) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
   Thread* thread = Thread::Current();
   PcDescriptors& result = PcDescriptors::Handle(thread->zone());
   {
     uword size = PcDescriptors::InstanceSize(data->length());
-    RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(PcDescriptors::kClassId, size, Heap::kOld);
     INC_STAT(thread, total_code_size, size);
     INC_STAT(thread, pc_desc_size, size);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(data->length());
     result.CopyData(data);
   }
   return result.raw();
 }
 
 
 RawPcDescriptors* PcDescriptors::New(intptr_t length) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
   Thread* thread = Thread::Current();
   PcDescriptors& result = PcDescriptors::Handle(thread->zone());
   {
     uword size = PcDescriptors::InstanceSize(length);
-    RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(PcDescriptors::kClassId, size, Heap::kOld);
     INC_STAT(thread, total_code_size, size);
     INC_STAT(thread, pc_desc_size, size);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(RawPcDescriptors::Kind kind) {
   switch (kind) {
-    case RawPcDescriptors::kDeopt:           return "deopt        ";
-    case RawPcDescriptors::kIcCall:          return "ic-call      ";
-    case RawPcDescriptors::kUnoptStaticCall: return "unopt-call   ";
-    case RawPcDescriptors::kRuntimeCall:     return "runtime-call ";
-    case RawPcDescriptors::kOsrEntry:        return "osr-entry    ";
-    case RawPcDescriptors::kOther:           return "other        ";
-    case RawPcDescriptors::kAnyKind:         UNREACHABLE(); break;
+    case RawPcDescriptors::kDeopt:
+      return "deopt        ";
+    case RawPcDescriptors::kIcCall:
+      return "ic-call      ";
+    case RawPcDescriptors::kUnoptStaticCall:
+      return "unopt-call   ";
+    case RawPcDescriptors::kRuntimeCall:
+      return "runtime-call ";
+    case RawPcDescriptors::kOsrEntry:
+      return "osr-entry    ";
+    case RawPcDescriptors::kOther:
+      return "other        ";
+    case RawPcDescriptors::kAnyKind:
+      UNREACHABLE();
+      break;
   }
   UNREACHABLE();
   return "";
 }
 
 
 void PcDescriptors::PrintHeaderString() {
   // 4 bits per hex digit + 2 for "0x".
   const int addr_width = (kBitsPerWord / 4) + 2;
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
-  THR_Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry-ix\n",
-            addr_width, "pc");
+  THR_Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry-ix\n", addr_width, "pc");
 }
 
 
 const char* PcDescriptors::ToCString() const {
-  // "*" in a printf format specifier tells it to read the field width from
-  // the printf argument list.
+// "*" in a printf format specifier tells it to read the field width from
+// the printf argument list.
 #define FORMAT "%#-*" Px "\t%s\t%" Pd "\t\t%s\t%" Pd "\n"
   if (Length() == 0) {
     return "empty PcDescriptors\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   {
     Iterator iter(*this, RawPcDescriptors::kAnyKind);
     while (iter.MoveNext()) {
-      len += OS::SNPrint(NULL, 0, FORMAT, addr_width,
-                         iter.PcOffset(),
-                         KindAsStr(iter.Kind()),
-                         iter.DeoptId(),
-                         iter.TokenPos().ToCString(),
-                         iter.TryIndex());
+      len += OS::SNPrint(NULL, 0, FORMAT, addr_width, iter.PcOffset(),
+                         KindAsStr(iter.Kind()), iter.DeoptId(),
+                         iter.TokenPos().ToCString(), iter.TryIndex());
     }
   }
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.MoveNext()) {
-    index += OS::SNPrint((buffer + index), (len - index), FORMAT, addr_width,
-                         iter.PcOffset(),
-                         KindAsStr(iter.Kind()),
-                         iter.DeoptId(),
-                         iter.TokenPos().ToCString(),
-                         iter.TryIndex());
+    index +=
+        OS::SNPrint((buffer + index), (len - index), FORMAT, addr_width,
+                    iter.PcOffset(), KindAsStr(iter.Kind()), iter.DeoptId(),
+                    iter.TokenPos().ToCString(), iter.TryIndex());
   }
   return buffer;
 #undef FORMAT
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same deoptimization id.
 // - No two ic-call descriptors have the same deoptimization id (type feedback).
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(const Function& function) const {
 #if defined(DEBUG)
   // Only check ids for unoptimized code that is optimizable.
   if (!function.IsOptimizable()) {
     return;
   }
   intptr_t max_deopt_id = 0;
   Iterator max_iter(*this,
                     RawPcDescriptors::kDeopt | RawPcDescriptors::kIcCall);
   while (max_iter.MoveNext()) {
     if (max_iter.DeoptId() > max_deopt_id) {
       max_deopt_id = max_iter.DeoptId();
     }
   }
 
   Zone* zone = Thread::Current()->zone();
-  BitVector* deopt_ids = new(zone) BitVector(zone, max_deopt_id + 1);
-  BitVector* iccall_ids = new(zone) BitVector(zone, max_deopt_id + 1);
+  BitVector* deopt_ids = new (zone) BitVector(zone, max_deopt_id + 1);
+  BitVector* iccall_ids = new (zone) BitVector(zone, max_deopt_id + 1);
   Iterator iter(*this, RawPcDescriptors::kDeopt | RawPcDescriptors::kIcCall);
   while (iter.MoveNext()) {
     // 'deopt_id' is set for kDeopt and kIcCall and must be unique for one kind.
     if (Thread::IsDeoptAfter(iter.DeoptId())) {
       // TODO(vegorov): some instructions contain multiple calls and have
       // multiple "after" targets recorded. Right now it is benign but might
       // lead to issues in the future. Fix that and enable verification.
       continue;
     }
     if (iter.Kind() == RawPcDescriptors::kDeopt) {
       ASSERT(!deopt_ids->Contains(iter.DeoptId()));
       deopt_ids->Add(iter.DeoptId());
     } else {
       ASSERT(!iccall_ids->Contains(iter.DeoptId()));
       iccall_ids->Add(iter.DeoptId());
     }
   }
 #endif  // DEBUG
 }
 
 
-TokenPosition CodeSourceMap::TokenPositionForPCOffset(
-    uword pc_offset) const {
+TokenPosition CodeSourceMap::TokenPositionForPCOffset(uword pc_offset) const {
   Iterator iterator(*this);
 
   TokenPosition result = TokenPosition::kNoSource;
 
   while (iterator.MoveNext()) {
     if (iterator.PcOffset() > pc_offset) {
       break;
     }
     result = iterator.TokenPos();
   }
@@ skipping 42 matching lines @@
   Script& current_script = Script::Handle();
   TokenPosition tp;
   while (iterator.MoveNext()) {
     const uword pc_offset = iterator.PcOffset();
     tp = code_source_map.TokenPositionForPCOffset(pc_offset);
     current_function ^=
         code_source_map.FunctionForPCOffset(code, function, pc_offset);
     current_script ^=
         code_source_map.ScriptForPCOffset(code, function, pc_offset);
     if (current_function.IsNull() || current_script.IsNull()) {
-      THR_Print("%#-*" Px "\t%s\t%s\n", addr_width,
-                pc_offset,
-                tp.ToCString(),
+      THR_Print("%#-*" Px "\t%s\t%s\n", addr_width, pc_offset, tp.ToCString(),
                 code_name);
       continue;
     }
     const String& uri = String::Handle(current_script.url());
     ASSERT(!uri.IsNull());
-    THR_Print("%#-*" Px "\t%s\t%s\t%s\n", addr_width,
-              pc_offset,
-              tp.ToCString(),
-              current_function.ToQualifiedCString(),
-              uri.ToCString());
+    THR_Print("%#-*" Px "\t%s\t%s\t%s\n", addr_width, pc_offset, tp.ToCString(),
+              current_function.ToQualifiedCString(), uri.ToCString());
   }
 }
 
 
 intptr_t CodeSourceMap::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void CodeSourceMap::SetLength(intptr_t value) const {
   StoreNonPointer(&raw_ptr()->length_, value);
 }
 
 
 void CodeSourceMap::CopyData(GrowableArray<uint8_t>* delta_encoded_data) {
   NoSafepointScope no_safepoint;
   uint8_t* data = UnsafeMutableNonPointer(&raw_ptr()->data()[0]);
   for (intptr_t i = 0; i < delta_encoded_data->length(); ++i) {
     data[i] = (*delta_encoded_data)[i];
   }
 }
 
 
 RawCodeSourceMap* CodeSourceMap::New(GrowableArray<uint8_t>* data) {
   ASSERT(Object::code_source_map_class() != Class::null());
   Thread* thread = Thread::Current();
   CodeSourceMap& result = CodeSourceMap::Handle(thread->zone());
   {
     uword size = CodeSourceMap::InstanceSize(data->length());
-    RawObject* raw = Object::Allocate(CodeSourceMap::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(CodeSourceMap::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(data->length());
     result.CopyData(data);
   }
   return result.raw();
 }
 
 
 RawCodeSourceMap* CodeSourceMap::New(intptr_t length) {
   ASSERT(Object::code_source_map_class() != Class::null());
   Thread* thread = Thread::Current();
   CodeSourceMap& result = CodeSourceMap::Handle(thread->zone());
   {
     uword size = CodeSourceMap::InstanceSize(length);
-    RawObject* raw = Object::Allocate(CodeSourceMap::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(CodeSourceMap::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   return result.raw();
 }
 
 
 const char* CodeSourceMap::ToCString() const {
-  // "*" in a printf format specifier tells it to read the field width from
-  // the printf argument list.
+// "*" in a printf format specifier tells it to read the field width from
+// the printf argument list.
 #define FORMAT "%#-*" Px "\t%s\n"
   if (Length() == 0) {
     return "empty CodeSourceMap\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   {
     Iterator iter(*this);
     while (iter.MoveNext()) {
-      len += OS::SNPrint(NULL, 0, FORMAT, addr_width,
-                         iter.PcOffset(),
+      len += OS::SNPrint(NULL, 0, FORMAT, addr_width, iter.PcOffset(),
                          iter.TokenPos().ToCString());
     }
   }
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   Iterator iter(*this);
   while (iter.MoveNext()) {
     index += OS::SNPrint((buffer + index), (len - index), FORMAT, addr_width,
-                         iter.PcOffset(),
-                         iter.TokenPos().ToCString());
+                         iter.PcOffset(), iter.TokenPos().ToCString());
   }
   return buffer;
 #undef FORMAT
 }
 
 
 // Encode integer in SLEB128 format.
 void CodeSourceMap::EncodeInteger(GrowableArray<uint8_t>* data,
                                   intptr_t value) {
   return EncodeSLEB128(data, value);
@@ skipping 34 matching lines @@
 
 
 RawStackmap* Stackmap::New(intptr_t pc_offset,
                            BitmapBuilder* bmap,
                            intptr_t slow_path_bit_count) {
   ASSERT(Object::stackmap_class() != Class::null());
   ASSERT(bmap != NULL);
   Stackmap& result = Stackmap::Handle();
   // Guard against integer overflow of the instance size computation.
   intptr_t length = bmap->Length();
-  intptr_t payload_size =
-      Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
-  if ((payload_size < 0) ||
-      (payload_size > kMaxLengthInBytes)) {
+  intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
+  if ((payload_size < 0) || (payload_size > kMaxLengthInBytes)) {
     // This should be caught before we reach here.
-    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n",
-           length);
+    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n", length);
   }
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
-    RawObject* raw = Object::Allocate(Stackmap::kClassId,
-                                      Stackmap::InstanceSize(length),
-                                      Heap::kOld);
+    RawObject* raw = Object::Allocate(
+        Stackmap::kClassId, Stackmap::InstanceSize(length), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   for (intptr_t i = 0; i < length; ++i) {
     result.SetBit(i, bmap->Get(i));
   }
   result.SetSlowPathBitCount(slow_path_bit_count);
   return result.raw();
 }
 
 
 RawStackmap* Stackmap::New(intptr_t length,
                            intptr_t slow_path_bit_count,
                            intptr_t pc_offset) {
   ASSERT(Object::stackmap_class() != Class::null());
   Stackmap& result = Stackmap::Handle();
   // Guard against integer overflow of the instance size computation.
-  intptr_t payload_size =
-  Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
-  if ((payload_size < 0) ||
-      (payload_size > kMaxLengthInBytes)) {
+  intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
+  if ((payload_size < 0) || (payload_size > kMaxLengthInBytes)) {
     // This should be caught before we reach here.
-    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n",
-           length);
+    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n", length);
   }
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
-    RawObject* raw = Object::Allocate(Stackmap::kClassId,
-                                      Stackmap::InstanceSize(length),
-                                      Heap::kOld);
+    RawObject* raw = Object::Allocate(
+        Stackmap::kClassId, Stackmap::InstanceSize(length), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   result.SetSlowPathBitCount(slow_path_bit_count);
@@ skipping 45 matching lines @@
 }
 
 
 void LocalVarDescriptors::GetInfo(intptr_t var_index,
                                   RawLocalVarDescriptors::VarInfo* info) const {
   ASSERT(var_index < Length());
   *info = raw()->data()[var_index];
 }
 
 
-static int PrintVarInfo(char* buffer, int len,
+static int PrintVarInfo(char* buffer,
+                        int len,
                         intptr_t i,
                         const String& var_name,
                         const RawLocalVarDescriptors::VarInfo& info) {
   const RawLocalVarDescriptors::VarInfoKind kind = info.kind();
   const int32_t index = info.index();
   if (kind == RawLocalVarDescriptors::kContextLevel) {
-    return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s level=%-3d scope=%-3d"
-                       " begin=%-3d end=%d\n",
-                       i,
-                       LocalVarDescriptors::KindToCString(kind),
-                       index,
-                       info.scope_id,
-                       static_cast<int>(info.begin_pos.Pos()),
+    return OS::SNPrint(buffer, len, "%2" Pd
+                                    " %-13s level=%-3d scope=%-3d"
+                                    " begin=%-3d end=%d\n",
+                       i, LocalVarDescriptors::KindToCString(kind), index,
+                       info.scope_id, static_cast<int>(info.begin_pos.Pos()),
                        static_cast<int>(info.end_pos.Pos()));
   } else if (kind == RawLocalVarDescriptors::kContextVar) {
-    return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s level=%-3d index=%-3d"
-                       " begin=%-3d end=%-3d name=%s\n",
-                       i,
-                       LocalVarDescriptors::KindToCString(kind),
-                       info.scope_id,
-                       index,
-                       static_cast<int>(info.begin_pos.Pos()),
-                       static_cast<int>(info.end_pos.Pos()),
-                       var_name.ToCString());
+    return OS::SNPrint(
+        buffer, len, "%2" Pd
+                     " %-13s level=%-3d index=%-3d"
+                     " begin=%-3d end=%-3d name=%s\n",
+        i, LocalVarDescriptors::KindToCString(kind), info.scope_id, index,
+        static_cast<int>(info.begin_pos.Pos()),
+        static_cast<int>(info.end_pos.Pos()), var_name.ToCString());
   } else {
-    return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s scope=%-3d index=%-3d"
-                       " begin=%-3d end=%-3d name=%s\n",
-                       i,
-                       LocalVarDescriptors::KindToCString(kind),
-                       info.scope_id,
-                       index,
-                       static_cast<int>(info.begin_pos.Pos()),
-                       static_cast<int>(info.end_pos.Pos()),
-                       var_name.ToCString());
+    return OS::SNPrint(
+        buffer, len, "%2" Pd
+                     " %-13s scope=%-3d index=%-3d"
+                     " begin=%-3d end=%-3d name=%s\n",
+        i, LocalVarDescriptors::KindToCString(kind), info.scope_id, index,
+        static_cast<int>(info.begin_pos.Pos()),
+        static_cast<int>(info.end_pos.Pos()), var_name.ToCString());
   }
 }
 
 
 const char* LocalVarDescriptors::ToCString() const {
   if (IsNull()) {
     return "LocalVarDescriptors(NULL)";
   }
   if (Length() == 0) {
     return "empty LocalVarDescriptors";
   }
   intptr_t len = 1;  // Trailing '\0'.
   String& var_name = String::Handle();
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
     GetInfo(i, &info);
     len += PrintVarInfo(NULL, 0, i, var_name, info);
   }
   char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
   buffer[0] = '\0';
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
     GetInfo(i, &info);
-    num_chars += PrintVarInfo((buffer + num_chars),
-                              (len - num_chars),
-                              i, var_name, info);
+    num_chars += PrintVarInfo((buffer + num_chars), (len - num_chars), i,
+                              var_name, info);
   }
   return buffer;
 }
 
 
 const char* LocalVarDescriptors::KindToCString(
     RawLocalVarDescriptors::VarInfoKind kind) {
   switch (kind) {
     case RawLocalVarDescriptors::kStackVar:
       return "StackVar";
     case RawLocalVarDescriptors::kContextVar:
       return "ContextVar";
     case RawLocalVarDescriptors::kContextLevel:
       return "ContextLevel";
     case RawLocalVarDescriptors::kSavedCurrentContext:
       return "CurrentCtx";
     default:
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
   ASSERT(Object::var_descriptors_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
-    FATAL2("Fatal error in LocalVarDescriptors::New: "
-           "invalid num_variables %" Pd ". Maximum is: %d\n",
-           num_variables, RawLocalVarDescriptors::kMaxIndex);
+    FATAL2(
+        "Fatal error in LocalVarDescriptors::New: "
+        "invalid num_variables %" Pd ". Maximum is: %d\n",
+        num_variables, RawLocalVarDescriptors::kMaxIndex);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
-    RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(LocalVarDescriptors::kClassId, size, Heap::kOld);
     INC_STAT(Thread::Current(), total_code_size, size);
     INC_STAT(Thread::Current(), vardesc_size, size);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_variables);
   }
   return result.raw();
 }
 
 
@@ skipping 78 matching lines @@
 
 
 void ExceptionHandlers::set_handled_types_data(const Array& value) const {
   StorePointer(&raw_ptr()->handled_types_data_, value.raw());
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::New(intptr_t num_handlers) {
   ASSERT(Object::exception_handlers_class() != Class::null());
   if ((num_handlers < 0) || (num_handlers >= kMaxHandlers)) {
-    FATAL1("Fatal error in ExceptionHandlers::New(): "
-           "invalid num_handlers %" Pd "\n",
-           num_handlers);
+    FATAL1(
+        "Fatal error in ExceptionHandlers::New(): "
+        "invalid num_handlers %" Pd "\n",
+        num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
-    RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(ExceptionHandlers::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_handlers);
   }
-  const Array& handled_types_data = (num_handlers == 0) ?
-      Object::empty_array() :
-      Array::Handle(Array::New(num_handlers, Heap::kOld));
+  const Array& handled_types_data =
+      (num_handlers == 0) ? Object::empty_array()
+                          : Array::Handle(Array::New(num_handlers, Heap::kOld));
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::New(const Array& handled_types_data) {
   ASSERT(Object::exception_handlers_class() != Class::null());
   const intptr_t num_handlers = handled_types_data.Length();
   if ((num_handlers < 0) || (num_handlers >= kMaxHandlers)) {
-    FATAL1("Fatal error in ExceptionHandlers::New(): "
-           "invalid num_handlers %" Pd "\n",
-           num_handlers);
+    FATAL1(
+        "Fatal error in ExceptionHandlers::New(): "
+        "invalid num_handlers %" Pd "\n",
+        num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
-    RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(ExceptionHandlers::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_handlers);
   }
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
 
 const char* ExceptionHandlers::ToCString() const {
 #define FORMAT1 "%" Pd " => %#x  (%" Pd " types) (outer %d)\n"
 #define FORMAT2 "  %d. %s\n"
   if (num_entries() == 0) {
     return "empty ExceptionHandlers\n";
   }
   Array& handled_types = Array::Handle();
   Type& type = Type::Handle();
   RawExceptionHandlers::HandlerInfo info;
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types =
         handled_types.IsNull() ? 0 : handled_types.Length();
-    len += OS::SNPrint(NULL, 0, FORMAT1,
-                       i,
-                       info.handler_pc_offset,
-                       num_types,
+    len += OS::SNPrint(NULL, 0, FORMAT1, i, info.handler_pc_offset, num_types,
                        info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
       ASSERT(!type.IsNull());
       len += OS::SNPrint(NULL, 0, FORMAT2, k, type.ToCString());
     }
   }
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types =
         handled_types.IsNull() ? 0 : handled_types.Length();
-    num_chars += OS::SNPrint((buffer + num_chars),
-                             (len - num_chars),
-                             FORMAT1,
-                             i,
-                             info.handler_pc_offset,
-                             num_types,
-                             info.outer_try_index);
+    num_chars +=
+        OS::SNPrint((buffer + num_chars), (len - num_chars), FORMAT1, i,
+                    info.handler_pc_offset, num_types, info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
-      num_chars += OS::SNPrint((buffer + num_chars),
-                               (len - num_chars),
-                               FORMAT2, k, type.ToCString());
+      num_chars += OS::SNPrint((buffer + num_chars), (len - num_chars), FORMAT2,
+                               k, type.ToCString());
     }
   }
   return buffer;
 #undef FORMAT1
 #undef FORMAT2
 }
 
 
 intptr_t DeoptInfo::FrameSize(const TypedData& packed) {
   NoSafepointScope no_safepoint;
@@ skipping 26 matching lines @@
   USE(frame_size);
 
   const intptr_t suffix_length = Reader::Read(&read_stream);
   if (suffix_length != 0) {
     ASSERT(suffix_length > 1);
     const intptr_t info_number = Reader::Read(&read_stream);
 
     TypedData& suffix = TypedData::Handle();
     Smi& offset = Smi::Handle();
     Smi& reason_and_flags = Smi::Handle();
-    DeoptTable::GetEntry(
-      table, info_number, &offset, &suffix, &reason_and_flags);
+    DeoptTable::GetEntry(table, info_number, &offset, &suffix,
+                         &reason_and_flags);
     UnpackInto(table, suffix, unpacked, suffix_length);
   }
 
-  while ((read_stream.PendingBytes() > 0) &&
-         (unpacked->length() < length)) {
+  while ((read_stream.PendingBytes() > 0) && (unpacked->length() < length)) {
     const intptr_t instruction = Reader::Read(&read_stream);
     const intptr_t from_index = Reader::Read(&read_stream);
     unpacked->Add(DeoptInstr::Create(instruction, from_index));
   }
 }
 
 
 void DeoptInfo::Unpack(const Array& table,
                        const TypedData& packed,
                        GrowableArray<DeoptInstr*>* unpacked) {
@@ skipping 18 matching lines @@
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
     len += OS::SNPrint(NULL, 0, FORMAT, deopt_instrs[i]->ToCString());
   }
 
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
 
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
-    index += OS::SNPrint((buffer + index),
-                         (len - index),
-                         FORMAT,
+    index += OS::SNPrint((buffer + index), (len - index), FORMAT,
                          deopt_instrs[i]->ToCString());
   }
 
   return buffer;
 #undef FORMAT
 }
 
 
 // Returns a bool so it can be asserted.
 bool DeoptInfo::VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
@@ skipping 16 matching lines @@
 
 const char* SingleTargetCache::ToCString() const {
   return "SingleTargetCache";
 }
 
 
 RawSingleTargetCache* SingleTargetCache::New() {
   SingleTargetCache& result = SingleTargetCache::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
-    RawObject* raw = Object::Allocate(SingleTargetCache::kClassId,
-                                      SingleTargetCache::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(SingleTargetCache::kClassId,
+                         SingleTargetCache::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_target(Code::Handle());
   result.set_entry_point(0);
   result.set_lower_limit(kIllegalCid);
   result.set_upper_limit(kIllegalCid);
   return result.raw();
 }
 
 
 void UnlinkedCall::set_target_name(const String& value) const {
   StorePointer(&raw_ptr()->target_name_, value.raw());
 }
 
 
 void UnlinkedCall::set_args_descriptor(const Array& value) const {
   StorePointer(&raw_ptr()->args_descriptor_, value.raw());
 }
 
 
 const char* UnlinkedCall::ToCString() const {
   return "UnlinkedCall";
 }
 
 
 RawUnlinkedCall* UnlinkedCall::New() {
   RawObject* raw = Object::Allocate(UnlinkedCall::kClassId,
-                                    UnlinkedCall::InstanceSize(),
-                                    Heap::kOld);
+                                    UnlinkedCall::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawUnlinkedCall*>(raw);
 }
 
 
 void ICData::ResetSwitchable(Zone* zone) const {
   ASSERT(NumArgsTested() == 1);
   set_ic_data_array(Array::Handle(zone, CachedEmptyICDataArray(1)));
 }
 
 
 const char* ICData::ToCString() const {
   const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
   const intptr_t num_checks = NumberOfChecks();
   return OS::SCreate(Thread::Current()->zone(),
-      "ICData target:'%s' num-args: %" Pd " num-checks: %" Pd "",
-      name.ToCString(), num_args, num_checks);
+                     "ICData target:'%s' num-args: %" Pd " num-checks: %" Pd "",
+                     name.ToCString(), num_args, num_checks);
 }
 
 
 RawFunction* ICData::Owner() const {
   Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsNull()) {
     ASSERT(Dart::snapshot_kind() == Snapshot::kAppNoJIT);
     return Function::null();
   } else if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
@@ skipping 235 matching lines @@
     return;
   }
   Zone* zone = Thread::Current()->zone();
   const String& name = String::Handle(target_name());
   const Class& smi_class = Class::Handle(Smi::Class());
   const Function& smi_op_target =
       Function::Handle(Resolver::ResolveDynamicAnyArgs(zone, smi_class, name));
   GrowableArray<intptr_t> class_ids(2);
   Function& target = Function::Handle();
   GetCheckAt(0, &class_ids, &target);
-  if ((target.raw() == smi_op_target.raw()) &&
-      (class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
+  if ((target.raw() == smi_op_target.raw()) && (class_ids[0] == kSmiCid) &&
+      (class_ids[1] == kSmiCid)) {
     // The smi fast path case, preserve the initial entry but reset the count.
     ClearCountAt(0);
     return;
   }
   WriteSentinelAt(0);
 }
 
 
 void ICData::ClearAndSetStaticTarget(const Function& func) const {
   if (IsImmutable()) {
@@ skipping 54 matching lines @@
     class_ids.Add(kSmiCid);
     class_ids.Add(kSmiCid);
     AddCheck(class_ids, smi_op_target);
     // 'AddCheck' sets the initial count to 1.
     SetCountAt(0, 0);
     is_smi_two_args_op = true;
   } else if (NumberOfChecks() == 1) {
     GrowableArray<intptr_t> class_ids(2);
     Function& target = Function::Handle();
     GetCheckAt(0, &class_ids, &target);
-    if ((target.raw() == smi_op_target.raw()) &&
-        (class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
+    if ((target.raw() == smi_op_target.raw()) && (class_ids[0] == kSmiCid) &&
+        (class_ids[1] == kSmiCid)) {
       is_smi_two_args_op = true;
     }
   }
   return is_smi_two_args_op;
 }
 
 
 // Used for unoptimized static calls when no class-ids are checked.
 void ICData::AddTarget(const Function& target) const {
   ASSERT(!target.IsNull());
@@ skipping 292 matching lines @@
   ASSERT(value <= Smi::kMaxValue);
   SetCountAt(index, Utils::Minimum(GetCountAt(index) + value, Smi::kMaxValue));
 }
 
 
 void ICData::SetCountAt(intptr_t index, intptr_t value) const {
   ASSERT(0 <= value);
   ASSERT(value <= Smi::kMaxValue);
 
   const Array& data = Array::Handle(ic_data());
-  const intptr_t data_pos = index * TestEntryLength() +
-      CountIndexFor(NumArgsTested());
+  const intptr_t data_pos =
+      index * TestEntryLength() + CountIndexFor(NumArgsTested());
   data.SetAt(data_pos, Smi::Handle(Smi::New(value)));
 }
 
 
 intptr_t ICData::GetCountAt(intptr_t index) const {
   ASSERT(Isolate::Current()->compilation_allowed());
   const Array& data = Array::Handle(ic_data());
-  const intptr_t data_pos = index * TestEntryLength() +
-      CountIndexFor(NumArgsTested());
+  const intptr_t data_pos =
+      index * TestEntryLength() + CountIndexFor(NumArgsTested());
   return Smi::Value(Smi::RawCast(data.At(data_pos)));
 }
 
 
 intptr_t ICData::AggregateCount() const {
   if (IsNull()) return 0;
   const intptr_t len = NumberOfChecks();
   intptr_t count = 0;
   for (intptr_t i = 0; i < len; i++) {
     count += GetCountAt(i);
   }
   return count;
 }
 
 
 void ICData::SetCodeAt(intptr_t index, const Code& value) const {
   ASSERT(!Isolate::Current()->compilation_allowed());
   const Array& data = Array::Handle(ic_data());
-  const intptr_t data_pos = index * TestEntryLength() +
-      CodeIndexFor(NumArgsTested());
+  const intptr_t data_pos =
+      index * TestEntryLength() + CodeIndexFor(NumArgsTested());
   data.SetAt(data_pos, value);
 }
 
 
 void ICData::SetEntryPointAt(intptr_t index, const Smi& value) const {
   ASSERT(!Isolate::Current()->compilation_allowed());
   const Array& data = Array::Handle(ic_data());
-  const intptr_t data_pos = index * TestEntryLength() +
-      EntryPointIndexFor(NumArgsTested());
+  const intptr_t data_pos =
+      index * TestEntryLength() + EntryPointIndexFor(NumArgsTested());
   data.SetAt(data_pos, value);
 }
 
 
 RawFunction* ICData::GetTargetForReceiverClassId(intptr_t class_id) const {
   const intptr_t len = NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (GetReceiverClassIdAt(i) == class_id) {
       return GetTargetAt(i);
     }
   }
   return Function::null();
 }
 
 
-RawICData* ICData::AsUnaryClassChecksForCid(
-    intptr_t cid, const Function& target) const {
+RawICData* ICData::AsUnaryClassChecksForCid(intptr_t cid,
+                                            const Function& target) const {
   ASSERT(!IsNull());
   const intptr_t kNumArgsTested = 1;
   ICData& result = ICData::Handle(ICData::NewFrom(*this, kNumArgsTested));
 
   // Copy count so that we copy the state "count == 0" vs "count > 0".
   result.AddReceiverCheck(cid, target, GetCountAt(0));
   return result.raw();
 }
 
 
@@ skipping 21 matching lines @@
         break;
       }
     }
     if (duplicate_class_id >= 0) {
       // This check is valid only when checking the receiver.
       ASSERT((arg_nr != 0) ||
              (result.GetTargetAt(duplicate_class_id) == GetTargetAt(i)));
       result.IncrementCountAt(duplicate_class_id, count);
     } else {
       // This will make sure that Smi is first if it exists.
-      result.AddReceiverCheck(class_id,
-                              Function::Handle(GetTargetAt(i)),
+      result.AddReceiverCheck(class_id, Function::Handle(GetTargetAt(i)),
                               count);
     }
   }
 
   return result.raw();
 }
 
 
 // (cid, count) tuple used to sort ICData by count.
 struct CidCount {
@@ skipping 33 matching lines @@
     }
     bool found = false;
     for (intptr_t r = 0; r < aggregate.length(); r++) {
       if (aggregate[r].cid == class_id) {
         aggregate[r].count += count;
         found = true;
         break;
       }
     }
     if (!found) {
-      aggregate.Add(CidCount(class_id, count,
-                             &Function::ZoneHandle(GetTargetAt(i))));
+      aggregate.Add(
+          CidCount(class_id, count, &Function::ZoneHandle(GetTargetAt(i))));
     }
   }
   aggregate.Sort(CidCount::HighestCountFirst);
 
   ICData& result = ICData::Handle(ICData::NewFrom(*this, kNumArgsTested));
   ASSERT(result.NumberOfChecks() == 0);
   // Room for all entries and the sentinel.
-  const intptr_t data_len =
-      result.TestEntryLength() * (aggregate.length() + 1);
+  const intptr_t data_len = result.TestEntryLength() * (aggregate.length() + 1);
   // Allocate the array but do not assign it to result until we have populated
   // it with the aggregate data and the terminating sentinel.
   const Array& data = Array::Handle(Array::New(data_len, Heap::kOld));
   intptr_t pos = 0;
   for (intptr_t i = 0; i < aggregate.length(); i++) {
     data.SetAt(pos + 0, Smi::Handle(Smi::New(aggregate[i].cid)));
     data.SetAt(pos + TargetIndexFor(1), *aggregate[i].function);
     data.SetAt(pos + CountIndexFor(1),
-        Smi::Handle(Smi::New(aggregate[i].count)));
+               Smi::Handle(Smi::New(aggregate[i].count)));
 
     pos += result.TestEntryLength();
   }
   WriteSentinel(data, result.TestEntryLength());
   result.set_ic_data_array(data);
   ASSERT(result.NumberOfChecks() == aggregate.length());
   return result.raw();
 }
 
 
@@ skipping 109 matching lines @@
 }
 
 
 RawArray* ICData::CachedEmptyICDataArray(intptr_t num_args_tested) {
   ASSERT(num_args_tested >= 0);
   ASSERT(num_args_tested < kCachedICDataArrayCount);
   return cached_icdata_arrays_[num_args_tested];
 }
 
 
-
 // Does not initialize ICData array.
 RawICData* ICData::NewDescriptor(Zone* zone,
                                  const Function& owner,
                                  const String& target_name,
                                  const Array& arguments_descriptor,
                                  intptr_t deopt_id,
                                  intptr_t num_args_tested,
                                  bool is_static_call) {
   ASSERT(!owner.IsNull());
   ASSERT(!target_name.IsNull());
   ASSERT(!arguments_descriptor.IsNull());
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested >= 0);
   ICData& result = ICData::Handle(zone);
   {
     // IC data objects are long living objects, allocate them in old generation.
-    RawObject* raw = Object::Allocate(ICData::kClassId,
-                                      ICData::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(ICData::kClassId, ICData::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_owner(owner);
   result.set_target_name(target_name);
   result.set_arguments_descriptor(arguments_descriptor);
   NOT_IN_PRECOMPILED(result.set_deopt_id(deopt_id));
   result.set_state_bits(0);
 #if defined(TAG_IC_DATA)
   result.set_tag(-1);
 #endif
   result.SetIsStaticCall(is_static_call);
   result.SetNumArgsTested(num_args_tested);
   return result.raw();
 }
 
 
 bool ICData::IsImmutable() const {
   const Array& data = Array::Handle(ic_data());
   return data.IsImmutable();
 }
 
 
 RawICData* ICData::New() {
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
-    RawObject* raw = Object::Allocate(ICData::kClassId,
-                                      ICData::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(ICData::kClassId, ICData::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_deopt_id(Thread::kNoDeoptId);
   result.set_state_bits(0);
 #if defined(TAG_IC_DATA)
   result.set_tag(-1);
 #endif
   return result.raw();
 }
 
 
 RawICData* ICData::New(const Function& owner,
                        const String& target_name,
                        const Array& arguments_descriptor,
                        intptr_t deopt_id,
                        intptr_t num_args_tested,
                        bool is_static_call) {
   Zone* zone = Thread::Current()->zone();
-  const ICData& result = ICData::Handle(zone,
-                                        NewDescriptor(zone,
-                                                      owner,
-                                                      target_name,
-                                                      arguments_descriptor,
-                                                      deopt_id,
-                                                      num_args_tested,
-                                                      is_static_call));
+  const ICData& result = ICData::Handle(
+      zone, NewDescriptor(zone, owner, target_name, arguments_descriptor,
+                          deopt_id, num_args_tested, is_static_call));
   result.set_ic_data_array(
       Array::Handle(zone, CachedEmptyICDataArray(num_args_tested)));
   return result.raw();
 }
 
 
 RawICData* ICData::NewFrom(const ICData& from, intptr_t num_args_tested) {
   const ICData& result = ICData::Handle(ICData::New(
-      Function::Handle(from.Owner()),
-      String::Handle(from.target_name()),
-      Array::Handle(from.arguments_descriptor()),
-      from.deopt_id(),
-      num_args_tested,
-      from.is_static_call()));
+      Function::Handle(from.Owner()), String::Handle(from.target_name()),
+      Array::Handle(from.arguments_descriptor()), from.deopt_id(),
+      num_args_tested, from.is_static_call()));
   // Copy deoptimization reasons.
   result.SetDeoptReasons(from.DeoptReasons());
   return result.raw();
 }
 
 
 RawICData* ICData::Clone(const ICData& from) {
   Zone* zone = Thread::Current()->zone();
   const ICData& result = ICData::Handle(ICData::NewDescriptor(
-      zone,
-      Function::Handle(zone, from.Owner()),
+      zone, Function::Handle(zone, from.Owner()),
       String::Handle(zone, from.target_name()),
-      Array::Handle(zone, from.arguments_descriptor()),
-      from.deopt_id(),
-      from.NumArgsTested(),
-      from.is_static_call()));
+      Array::Handle(zone, from.arguments_descriptor()), from.deopt_id(),
+      from.NumArgsTested(), from.is_static_call()));
   // Clone entry array.
   const Array& from_array = Array::Handle(zone, from.ic_data());
   const intptr_t len = from_array.Length();
-  const Array& cloned_array =
-      Array::Handle(zone, Array::New(len, Heap::kOld));
+  const Array& cloned_array = Array::Handle(zone, Array::New(len, Heap::kOld));
   Object& obj = Object::Handle(zone);
   for (intptr_t i = 0; i < len; i++) {
     obj = from_array.At(i);
     cloned_array.SetAt(i, obj);
   }
   result.set_ic_data_array(cloned_array);
   // Copy deoptimization reasons.
   result.SetDeoptReasons(from.DeoptReasons());
   return result.raw();
 }
@@ skipping 19 matching lines @@
 
 intptr_t Code::Comments::Length() const {
   if (comments_.IsNull()) {
     return 0;
   }
   return comments_.Length() / kNumberOfEntries;
 }
 
 
 intptr_t Code::Comments::PCOffsetAt(intptr_t idx) const {
-  return Smi::Value(Smi::RawCast(
-      comments_.At(idx * kNumberOfEntries + kPCOffsetEntry)));
+  return Smi::Value(
+      Smi::RawCast(comments_.At(idx * kNumberOfEntries + kPCOffsetEntry)));
 }
 
 
-void Code::Comments::SetPCOffsetAt(intptr_t idx, intptr_t pc)  {
+void Code::Comments::SetPCOffsetAt(intptr_t idx, intptr_t pc) {
   comments_.SetAt(idx * kNumberOfEntries + kPCOffsetEntry,
                   Smi::Handle(Smi::New(pc)));
 }
 
 
 RawString* Code::Comments::CommentAt(intptr_t idx) const {
   return String::RawCast(comments_.At(idx * kNumberOfEntries + kCommentEntry));
 }
 
 
 void Code::Comments::SetCommentAt(intptr_t idx, const String& comment) {
   comments_.SetAt(idx * kNumberOfEntries + kCommentEntry, comment);
 }
 
 
-Code::Comments::Comments(const Array& comments)
-    : comments_(comments) {
-}
+Code::Comments::Comments(const Array& comments) : comments_(comments) {}
 
 
 RawLocalVarDescriptors* Code::GetLocalVarDescriptors() const {
   const LocalVarDescriptors& v = LocalVarDescriptors::Handle(var_descriptors());
   if (v.IsNull()) {
     ASSERT(!is_optimized());
     const Function& f = Function::Handle(function());
     if (f.kernel_function() != NULL) {
       return v.raw();
     }
@@ skipping 15 matching lines @@
 
 
 void Code::set_is_alive(bool value) const {
   set_state_bits(AliveBit::update(value, raw_ptr()->state_bits_));
 }
 
 
 void Code::set_stackmaps(const Array& maps) const {
   ASSERT(maps.IsOld());
   StorePointer(&raw_ptr()->stackmaps_, maps.raw());
-  INC_STAT(Thread::Current(),
-           total_code_size,
+  INC_STAT(Thread::Current(), total_code_size,
            maps.IsNull() ? 0 : maps.Length() * sizeof(uword));
 }
 
 
 void Code::set_deopt_info_array(const Array& array) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   ASSERT(array.IsOld());
   StorePointer(&raw_ptr()->deopt_info_array_, array.raw());
 #endif
 }
 
 
 void Code::set_static_calls_target_table(const Array& value) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   StorePointer(&raw_ptr()->static_calls_target_table_, value.raw());
 #endif
 #if defined(DEBUG)
   // Check that the table is sorted by pc offsets.
   // FlowGraphCompiler::AddStaticCallTarget adds pc-offsets to the table while
   // emitting assembly. This guarantees that every succeeding pc-offset is
   // larger than the previously added one.
-  for (intptr_t i = kSCallTableEntryLength;
-      i < value.Length();
-      i += kSCallTableEntryLength) {
+  for (intptr_t i = kSCallTableEntryLength; i < value.Length();
+       i += kSCallTableEntryLength) {
     ASSERT(value.At(i - kSCallTableEntryLength) < value.At(i));
   }
 #endif  // DEBUG
 }
 
 
 bool Code::HasBreakpoint() const {
   if (!FLAG_support_debugger) {
     return false;
   }
@@ skipping 68 matching lines @@
 
 RawFunction* Code::GetStaticCallTargetFunctionAt(uword pc) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
   return Function::null();
 #else
   const intptr_t i = BinarySearchInSCallTable(pc);
   if (i < 0) {
     return Function::null();
   }
-  const Array& array =
-      Array::Handle(raw_ptr()->static_calls_target_table_);
+  const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
   Function& function = Function::Handle();
   function ^= array.At(i + kSCallTableFunctionEntry);
   return function.raw();
 #endif
 }
 
 
 RawCode* Code::GetStaticCallTargetCodeAt(uword pc) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
   return Code::null();
 #else
   const intptr_t i = BinarySearchInSCallTable(pc);
   if (i < 0) {
     return Code::null();
   }
-  const Array& array =
-      Array::Handle(raw_ptr()->static_calls_target_table_);
+  const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
   Code& code = Code::Handle();
   code ^= array.At(i + kSCallTableCodeEntry);
   return code.raw();
 #endif
 }
 
 
 void Code::SetStaticCallTargetCodeAt(uword pc, const Code& code) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   const intptr_t i = BinarySearchInSCallTable(pc);
   ASSERT(i >= 0);
-  const Array& array =
-      Array::Handle(raw_ptr()->static_calls_target_table_);
+  const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
   ASSERT(code.IsNull() ||
          (code.function() == array.At(i + kSCallTableFunctionEntry)));
   array.SetAt(i + kSCallTableCodeEntry, code);
 #endif
 }
 
 
 void Code::SetStubCallTargetCodeAt(uword pc, const Code& code) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   const intptr_t i = BinarySearchInSCallTable(pc);
   ASSERT(i >= 0);
-  const Array& array =
-      Array::Handle(raw_ptr()->static_calls_target_table_);
+  const Array& array = Array::Handle(raw_ptr()->static_calls_target_table_);
 #if defined(DEBUG)
   if (array.At(i + kSCallTableFunctionEntry) == Function::null()) {
     ASSERT(!code.IsNull() && Object::Handle(code.owner()).IsClass());
   } else {
     ASSERT(code.IsNull() ||
            (code.function() == array.At(i + kSCallTableFunctionEntry)));
   }
 #endif
   array.SetAt(i + kSCallTableCodeEntry, code);
 #endif
 }
 
 
 void Code::Disassemble(DisassemblyFormatter* formatter) const {
 #ifndef PRODUCT
   if (!FLAG_support_disassembler) {
     return;
   }
   const Instructions& instr = Instructions::Handle(instructions());
   uword start = instr.PayloadStart();
   if (formatter == NULL) {
     Disassembler::Disassemble(start, start + instr.size(), *this);
   } else {
     Disassembler::Disassemble(start, start + instr.size(), formatter, *this);
   }
 #endif
 }
 
 
-const Code::Comments& Code::comments() const  {
+const Code::Comments& Code::comments() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   Comments* comments = new Code::Comments(Array::Handle());
 #else
   Comments* comments = new Code::Comments(Array::Handle(raw_ptr()->comments_));
 #endif
   return *comments;
 }
 
 
 void Code::set_comments(const Code::Comments& comments) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   ASSERT(comments.comments_.IsOld());
   StorePointer(&raw_ptr()->comments_, comments.comments_.raw());
 #endif
 }
 
 
 void Code::SetPrologueOffset(intptr_t offset) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
 #else
   ASSERT(offset >= 0);
   StoreSmi(
-      reinterpret_cast<RawSmi* const *>(&raw_ptr()->return_address_metadata_),
+      reinterpret_cast<RawSmi* const*>(&raw_ptr()->return_address_metadata_),
       Smi::New(offset));
 #endif
 }
 
 
 intptr_t Code::GetPrologueOffset() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
   return -1;
 #else
   const Object& object = Object::Handle(raw_ptr()->return_address_metadata_);
@@ skipping 168 matching lines @@
       ObjectPool::Handle(assembler->object_pool_wrapper().MakeObjectPool());
 
   // Allocate the Code and Instructions objects.  Code is allocated first
   // because a GC during allocation of the code will leave the instruction
   // pages read-only.
   intptr_t pointer_offset_count = assembler->CountPointerOffsets();
   Code& code = Code::ZoneHandle(Code::New(pointer_offset_count));
 #ifdef TARGET_ARCH_IA32
   assembler->set_code_object(code);
 #endif
-  Instructions& instrs = Instructions::ZoneHandle(
-      Instructions::New(assembler->CodeSize(),
-                        assembler->has_single_entry_point()));
+  Instructions& instrs = Instructions::ZoneHandle(Instructions::New(
+      assembler->CodeSize(), assembler->has_single_entry_point()));
   INC_STAT(Thread::Current(), total_instr_size, assembler->CodeSize());
   INC_STAT(Thread::Current(), total_code_size, assembler->CodeSize());
 
   // Copy the instructions into the instruction area and apply all fixups.
   // Embedded pointers are still in handles at this point.
   MemoryRegion region(reinterpret_cast<void*>(instrs.PayloadStart()),
                       instrs.size());
   assembler->FinalizeInstructions(region);
   CPU::FlushICache(instrs.PayloadStart(), instrs.size());
 
   code.set_compile_timestamp(OS::GetCurrentMonotonicMicros());
 #ifndef PRODUCT
-  CodeObservers::NotifyAll(name,
-                           instrs.PayloadStart(),
-                           assembler->prologue_offset(),
-                           instrs.size(),
+  CodeObservers::NotifyAll(name, instrs.PayloadStart(),
+                           assembler->prologue_offset(), instrs.size(),
                            optimized);
 #endif
   {
     NoSafepointScope no_safepoint;
     const ZoneGrowableArray<intptr_t>& pointer_offsets =
         assembler->GetPointerOffsets();
     ASSERT(pointer_offsets.length() == pointer_offset_count);
     ASSERT(code.pointer_offsets_length() == pointer_offsets.length());
 
     // Set pointer offsets list in Code object and resolve all handles in
     // the instruction stream to raw objects.
     for (intptr_t i = 0; i < pointer_offsets.length(); i++) {
       intptr_t offset_in_instrs = pointer_offsets[i];
       code.SetPointerOffsetAt(i, offset_in_instrs);
       uword addr = region.start() + offset_in_instrs;
       const Object* object = *reinterpret_cast<Object**>(addr);
       instrs.raw()->StorePointer(reinterpret_cast<RawObject**>(addr),
                                  object->raw());
     }
 
     // Hook up Code and Instructions objects.
     code.SetActiveInstructions(instrs);
     code.set_instructions(instrs);
     code.set_is_alive(true);
 
     // Set object pool in Instructions object.
-    INC_STAT(Thread::Current(),
-             total_code_size, object_pool.Length() * sizeof(uintptr_t));
+    INC_STAT(Thread::Current(), total_code_size,
+             object_pool.Length() * sizeof(uintptr_t));
     code.set_object_pool(object_pool.raw());
 
     if (FLAG_write_protect_code) {
       uword address = RawObject::ToAddr(instrs.raw());
-      bool status = VirtualMemory::Protect(
-          reinterpret_cast<void*>(address),
-          instrs.raw()->Size(),
-          VirtualMemory::kReadExecute);
+      bool status = VirtualMemory::Protect(reinterpret_cast<void*>(address),
+                                           instrs.raw()->Size(),
+                                           VirtualMemory::kReadExecute);
       ASSERT(status);
     }
   }
   code.set_comments(assembler->GetCodeComments());
   if (assembler->prologue_offset() >= 0) {
     code.SetPrologueOffset(assembler->prologue_offset());
   } else {
     // No prologue was ever entered, optimistically assume nothing was ever
     // pushed onto the stack.
     code.SetPrologueOffset(assembler->CodeSize());
   }
-  INC_STAT(Thread::Current(),
-           total_code_size, code.comments().comments_.Length());
+  INC_STAT(Thread::Current(), total_code_size,
+           code.comments().comments_.Length());
   return code.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const Function& function,
                             Assembler* assembler,
                             bool optimized) {
-  // Calling ToLibNamePrefixedQualifiedCString is very expensive,
-  // try to avoid it.
+// Calling ToLibNamePrefixedQualifiedCString is very expensive,
+// try to avoid it.
 #ifndef PRODUCT
   if (CodeObservers::AreActive()) {
-    return FinalizeCode(function.ToLibNamePrefixedQualifiedCString(),
-                        assembler,
+    return FinalizeCode(function.ToLibNamePrefixedQualifiedCString(), assembler,
                         optimized);
   }
 #endif  // !PRODUCT
   return FinalizeCode("", assembler, optimized);
 }
 
 
 bool Code::SlowFindRawCodeVisitor::FindObject(RawObject* raw_obj) const {
   return RawCode::ContainsPC(raw_obj, pc_);
 }
@@ skipping 96 matching lines @@
 
 
 const char* Code::Name() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsNull()) {
     // Regular stub.
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
     const char* name = StubCode::NameOfStub(UncheckedEntryPoint());
     ASSERT(name != NULL);
-    char* stub_name = OS::SCreate(zone,
-        "%s%s", Symbols::StubPrefix().ToCString(), name);
+    char* stub_name =
+        OS::SCreate(zone, "%s%s", Symbols::StubPrefix().ToCString(), name);
     return stub_name;
   } else if (obj.IsClass()) {
     // Allocation stub.
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
     const Class& cls = Class::Cast(obj);
     String& cls_name = String::Handle(zone, cls.ScrubbedName());
     ASSERT(!cls_name.IsNull());
-    char* stub_name = OS::SCreate(zone,
-        "%s%s", Symbols::AllocationStubFor().ToCString(), cls_name.ToCString());
+    char* stub_name =
+        OS::SCreate(zone, "%s%s", Symbols::AllocationStubFor().ToCString(),
+                    cls_name.ToCString());
     return stub_name;
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
     // Same as scrubbed name.
     return String::Handle(Function::Cast(obj).UserVisibleName()).ToCString();
   }
 }
 
 
 const char* Code::QualifiedName() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsFunction()) {
-    return String::Handle(
-        Function::Cast(obj).QualifiedScrubbedName()).ToCString();
+    return String::Handle(Function::Cast(obj).QualifiedScrubbedName())
+        .ToCString();
   }
   return Name();
 }
 
 
 bool Code::IsAllocationStubCode() const {
   const Object& obj = Object::Handle(owner());
   return obj.IsClass();
 }
 
@@ skipping 44 matching lines @@
   // store buffer update is not needed here.
   StorePointer(&raw_ptr()->active_instructions_, instructions.raw());
   StoreNonPointer(&raw_ptr()->entry_point_,
                   Instructions::UncheckedEntryPoint(instructions.raw()));
   StoreNonPointer(&raw_ptr()->checked_entry_point_,
                   Instructions::CheckedEntryPoint(instructions.raw()));
 #endif
 }
 
 
-RawStackmap* Code::GetStackmap(
-    uint32_t pc_offset, Array* maps, Stackmap* map) const {
+RawStackmap* Code::GetStackmap(uint32_t pc_offset,
+                               Array* maps,
+                               Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
   NoSafepointScope no_safepoint;
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
     return Stackmap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
   // frame slots which are marked as having objects.
@@ skipping 100 matching lines @@
     inlined_functions.Clear();
 
     THR_Print("inlined: ");
     GetInlinedFunctionsAt(start.Value(), &inlined_functions);
 
     for (intptr_t j = 0; j < inlined_functions.length(); j++) {
       const char* name = inlined_functions[j]->ToQualifiedCString();
       THR_Print("  %s <-", name);
     }
     if (inlined_functions[inlined_functions.length() - 1]->raw() !=
-           inliner.raw()) {
+        inliner.raw()) {
       THR_Print(" (ERROR, missing inliner)\n");
     } else {
       THR_Print("\n");
     }
   }
   THR_Print("Inlined ids:\n");
   const Array& id_map = Array::Handle(GetInlinedIdToFunction());
   Function& function = Function::Handle();
   for (intptr_t i = 0; i < id_map.Length(); i++) {
     function ^= id_map.At(i);
@@ skipping 22 matching lines @@
   ASSERT(num_variables >= 0);
   ASSERT(Object::context_class() != Class::null());
 
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Context::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
   Context& result = Context::Handle();
   {
-    RawObject* raw = Object::Allocate(Context::kClassId,
-                                      Context::InstanceSize(num_variables),
-                                      space);
+    RawObject* raw = Object::Allocate(
+        Context::kClassId, Context::InstanceSize(num_variables), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   if (IsNull()) {
     return "Context (Null)";
   }
   Zone* zone = Thread::Current()->zone();
   const Context& parent_ctx = Context::Handle(parent());
   if (parent_ctx.IsNull()) {
     return zone->PrintToString("Context num_variables: %" Pd "",
                                num_variables());
   } else {
     const char* parent_str = parent_ctx.ToCString();
-    return zone->PrintToString(
-        "Context num_variables: %" Pd " parent:{ %s }",
-        num_variables(), parent_str);
+    return zone->PrintToString("Context num_variables: %" Pd " parent:{ %s }",
+                               num_variables(), parent_str);
   }
 }
 
 
 static void IndentN(int count) {
   for (int i = 0; i < count; i++) {
     THR_Print(" ");
   }
 }
 
@@ skipping 31 matching lines @@
 RawContextScope* ContextScope::New(intptr_t num_variables, bool is_implicit) {
   ASSERT(Object::context_scope_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ContextScope::New: invalid num_variables %" Pd "\n",
            num_variables);
   }
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
-    RawObject* raw = Object::Allocate(ContextScope::kClassId,
-                                      size,
-                                      Heap::kOld);
+    RawObject* raw = Object::Allocate(ContextScope::kClassId, size, Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_num_variables(num_variables);
     result.set_is_implicit(is_implicit);
   }
   return result.raw();
 }
 
 
 TokenPosition ContextScope::TokenIndexAt(intptr_t scope_index) const {
@@ skipping 54 matching lines @@
                Bool::Get(is_const).raw());
 }
 
 
 RawAbstractType* ContextScope::TypeAt(intptr_t scope_index) const {
   ASSERT(!IsConstAt(scope_index));
   return VariableDescAddr(scope_index)->type;
 }
 
 
-void ContextScope::SetTypeAt(
-    intptr_t scope_index, const AbstractType& type) const {
+void ContextScope::SetTypeAt(intptr_t scope_index,
+                             const AbstractType& type) const {
   StorePointer(&(VariableDescAddr(scope_index)->type), type.raw());
 }
 
 
 RawInstance* ContextScope::ConstValueAt(intptr_t scope_index) const {
   ASSERT(IsConstAt(scope_index));
   return VariableDescAddr(scope_index)->value;
 }
 
 
-void ContextScope::SetConstValueAt(
-    intptr_t scope_index, const Instance& value) const {
+void ContextScope::SetConstValueAt(intptr_t scope_index,
+                                   const Instance& value) const {
   ASSERT(IsConstAt(scope_index));
   StorePointer(&(VariableDescAddr(scope_index)->value), value.raw());
 }
 
 
 intptr_t ContextScope::ContextIndexAt(intptr_t scope_index) const {
   return Smi::Value(VariableDescAddr(scope_index)->context_index);
 }
 
 
@@ skipping 18 matching lines @@
 
 const char* ContextScope::ToCString() const {
   const char* prev_cstr = "ContextScope:";
   String& name = String::Handle();
   for (int i = 0; i < num_variables(); i++) {
     name = NameAt(i);
     const char* cname = name.ToCString();
     TokenPosition pos = TokenIndexAt(i);
     intptr_t idx = ContextIndexAt(i);
     intptr_t lvl = ContextLevelAt(i);
-    char* chars = OS::SCreate(Thread::Current()->zone(),
-        "%s\nvar %s  token-pos %s  ctx lvl %" Pd "  index %" Pd "",
-        prev_cstr, cname, pos.ToCString(), lvl, idx);
+    char* chars =
+        OS::SCreate(Thread::Current()->zone(),
+                    "%s\nvar %s  token-pos %s  ctx lvl %" Pd "  index %" Pd "",
+                    prev_cstr, cname, pos.ToCString(), lvl, idx);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 RawArray* MegamorphicCache::buckets() const {
   return raw_ptr()->buckets_;
 }
 
@@ skipping 31 matching lines @@
 }
 
 
 void MegamorphicCache::set_arguments_descriptor(const Array& value) const {
   StorePointer(&raw_ptr()->args_descriptor_, value.raw());
 }
 
 
 RawMegamorphicCache* MegamorphicCache::New() {
   MegamorphicCache& result = MegamorphicCache::Handle();
-  { RawObject* raw = Object::Allocate(MegamorphicCache::kClassId,
-                                      MegamorphicCache::InstanceSize(),
-                                      Heap::kOld);
+  {
+    RawObject* raw =
+        Object::Allocate(MegamorphicCache::kClassId,
+                         MegamorphicCache::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_filled_entry_count(0);
   return result.raw();
 }
 
 
 RawMegamorphicCache* MegamorphicCache::New(const String& target_name,
                                            const Array& arguments_descriptor) {
   MegamorphicCache& result = MegamorphicCache::Handle();
-  { RawObject* raw = Object::Allocate(MegamorphicCache::kClassId,
-                                      MegamorphicCache::InstanceSize(),
-                                      Heap::kOld);
+  {
+    RawObject* raw =
+        Object::Allocate(MegamorphicCache::kClassId,
+                         MegamorphicCache::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   const intptr_t capacity = kInitialCapacity;
-  const Array& buckets = Array::Handle(
-      Array::New(kEntryLength * capacity, Heap::kOld));
-  const Function& handler = Function::Handle(
-      MegamorphicCacheTable::miss_handler(Isolate::Current()));
+  const Array& buckets =
+      Array::Handle(Array::New(kEntryLength * capacity, Heap::kOld));
+  const Function& handler =
+      Function::Handle(MegamorphicCacheTable::miss_handler(Isolate::Current()));
   for (intptr_t i = 0; i < capacity; ++i) {
     SetEntry(buckets, i, smi_illegal_cid(), handler);
   }
   result.set_buckets(buckets);
   result.set_mask(capacity - 1);
   result.set_target_name(target_name);
   result.set_arguments_descriptor(arguments_descriptor);
   result.set_filled_entry_count(0);
   return result.raw();
 }
@@ skipping 45 matching lines @@
       return;
     }
     i = (i + 1) & id_mask;
   } while (i != index);
   UNREACHABLE();
 }
 
 
 const char* MegamorphicCache::ToCString() const {
   const String& name = String::Handle(target_name());
-  return OS::SCreate(Thread::Current()->zone(),
-                     "MegamorphicCache(%s)", name.ToCString());
+  return OS::SCreate(Thread::Current()->zone(), "MegamorphicCache(%s)",
+                     name.ToCString());
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
   ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
-    RawObject* raw = Object::Allocate(SubtypeTestCache::kClassId,
-                                      SubtypeTestCache::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(SubtypeTestCache::kClassId,
+                         SubtypeTestCache::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   const Array& cache = Array::Handle(Array::New(kTestEntryLength, Heap::kOld));
   result.set_cache(cache);
   return result.raw();
 }
 
 
 void SubtypeTestCache::set_cache(const Array& value) const {
@@ skipping 58 matching lines @@
 const char* Error::ToCString() const {
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
 }
 
 
 RawApiError* ApiError::New() {
   ASSERT(Object::api_error_class() != Class::null());
   RawObject* raw = Object::Allocate(ApiError::kClassId,
-                                    ApiError::InstanceSize(),
-                                    Heap::kOld);
+                                    ApiError::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawApiError*>(raw);
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
   ASSERT(Object::api_error_class() != Class::null());
   ApiError& result = ApiError::Handle();
   {
-    RawObject* raw = Object::Allocate(ApiError::kClassId,
-                                      ApiError::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(ApiError::kClassId, ApiError::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
 void ApiError::set_message(const String& message) const {
   StorePointer(&raw_ptr()->message_, message.raw());
 }
 
 
 const char* ApiError::ToErrorCString() const {
   const String& msg_str = String::Handle(message());
   return msg_str.ToCString();
 }
 
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
 RawLanguageError* LanguageError::New() {
   ASSERT(Object::language_error_class() != Class::null());
   RawObject* raw = Object::Allocate(LanguageError::kClassId,
-                                    LanguageError::InstanceSize(),
-                                    Heap::kOld);
+                                    LanguageError::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawLanguageError*>(raw);
 }
 
 
 RawLanguageError* LanguageError::NewFormattedV(const Error& prev_error,
                                                const Script& script,
                                                TokenPosition token_pos,
                                                bool report_after_token,
                                                Report::Kind kind,
                                                Heap::Space space,
                                                const char* format,
                                                va_list args) {
   ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
     RawObject* raw = Object::Allocate(LanguageError::kClassId,
-                                      LanguageError::InstanceSize(),
-                                      space);
+                                      LanguageError::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_previous_error(prev_error);
   result.set_script(script);
   result.set_token_pos(token_pos);
   result.set_report_after_token(report_after_token);
   result.set_kind(kind);
-  result.set_message(String::Handle(
-      String::NewFormattedV(format, args, space)));
+  result.set_message(
+      String::Handle(String::NewFormattedV(format, args, space)));
   return result.raw();
 }
 
 
 RawLanguageError* LanguageError::NewFormatted(const Error& prev_error,
                                               const Script& script,
                                               TokenPosition token_pos,
                                               bool report_after_token,
                                               Report::Kind kind,
                                               Heap::Space space,
-                                              const char* format, ...) {
+                                              const char* format,
+                                              ...) {
   va_list args;
   va_start(args, format);
   RawLanguageError* result = LanguageError::NewFormattedV(
-      prev_error, script, token_pos, report_after_token,
-      kind, space, format, args);
+      prev_error, script, token_pos, report_after_token, kind, space, format,
+      args);
   NoSafepointScope no_safepoint;
   va_end(args);
   return result;
 }
 
 
 RawLanguageError* LanguageError::New(const String& formatted_message,
                                      Report::Kind kind,
                                      Heap::Space space) {
   ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
     RawObject* raw = Object::Allocate(LanguageError::kClassId,
-                                      LanguageError::InstanceSize(),
-                                      space);
+                                      LanguageError::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_formatted_message(formatted_message);
   result.set_kind(kind);
   return result.raw();
 }
 
 
 void LanguageError::set_previous_error(const Error& value) const {
@@ skipping 30 matching lines @@
 void LanguageError::set_formatted_message(const String& value) const {
   StorePointer(&raw_ptr()->formatted_message_, value.raw());
 }
 
 
 RawString* LanguageError::FormatMessage() const {
   if (formatted_message() != String::null()) {
     return formatted_message();
   }
   String& result = String::Handle(
-      Report::PrependSnippet(kind(),
-                             Script::Handle(script()),
-                             token_pos(),
-                             report_after_token(),
-                             String::Handle(message())));
+      Report::PrependSnippet(kind(), Script::Handle(script()), token_pos(),
+                             report_after_token(), String::Handle(message())));
   // Prepend previous error message.
   const Error& prev_error = Error::Handle(previous_error());
   if (!prev_error.IsNull()) {
     result = String::Concat(
         String::Handle(String::New(prev_error.ToErrorCString())), result);
   }
   set_formatted_message(result);
   return result.raw();
 }
 
 
 const char* LanguageError::ToErrorCString() const {
   const String& msg_str = String::Handle(FormatMessage());
   return msg_str.ToCString();
 }
 
 
 const char* LanguageError::ToCString() const {
   return "LanguageError";
 }
 
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
-    RawObject* raw = Object::Allocate(UnhandledException::kClassId,
-                                      UnhandledException::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(UnhandledException::kClassId,
+                         UnhandledException::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_exception(exception);
   result.set_stacktrace(stacktrace);
   return result.raw();
 }
 
 
 RawUnhandledException* UnhandledException::New(Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
-    RawObject* raw = Object::Allocate(UnhandledException::kClassId,
-                                      UnhandledException::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(UnhandledException::kClassId,
+                         UnhandledException::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_exception(Object::null_instance());
   result.set_stacktrace(Stacktrace::Handle());
   return result.raw();
 }
 
 
 void UnhandledException::set_exception(const Instance& exception) const {
@@ skipping 25 matching lines @@
       exc_str = "<Received error while converting exception to string>";
     }
   }
   const Instance& stack = Instance::Handle(stacktrace());
   strtmp = DartLibraryCalls::ToString(stack);
   const char* stack_str =
       "<Received error while converting stack trace to string>";
   if (!strtmp.IsError()) {
     stack_str = strtmp.ToCString();
   }
-  return OS::SCreate(thread->zone(),
-      "Unhandled exception:\n%s\n%s", exc_str, stack_str);
+  return OS::SCreate(thread->zone(), "Unhandled exception:\n%s\n%s", exc_str,
+                     stack_str);
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
   ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
     RawObject* raw = Object::Allocate(UnwindError::kClassId,
-                                      UnwindError::InstanceSize(),
-                                      space);
+                                      UnwindError::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_message(message);
   result.set_is_user_initiated(false);
   result.set_is_vm_restart(false);
   return result.raw();
 }
 
 
@@ skipping 61 matching lines @@
     // Raw bits compare.
     const intptr_t instance_size = SizeFromClass();
     ASSERT(instance_size != 0);
     const intptr_t other_instance_size = other.SizeFromClass();
     ASSERT(other_instance_size != 0);
     if (instance_size != other_instance_size) {
       return false;
     }
     uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
     uword other_addr = reinterpret_cast<uword>(other.raw_ptr());
-    for (intptr_t offset = Instance::NextFieldOffset();
-         offset < instance_size;
+    for (intptr_t offset = Instance::NextFieldOffset(); offset < instance_size;
          offset += kWordSize) {
       if ((*reinterpret_cast<RawObject**>(this_addr + offset)) !=
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
         return false;
       }
     }
   }
   return true;
 }
 
 
 uword Instance::ComputeCanonicalTableHash() const {
   ASSERT(!IsNull());
   NoSafepointScope no_safepoint;
   const intptr_t instance_size = SizeFromClass();
   ASSERT(instance_size != 0);
   uword hash = instance_size;
   uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
-  for (intptr_t offset = Instance::NextFieldOffset();
-       offset < instance_size;
+  for (intptr_t offset = Instance::NextFieldOffset(); offset < instance_size;
        offset += kWordSize) {
     uword value = reinterpret_cast<uword>(
         *reinterpret_cast<RawObject**>(this_addr + offset));
     hash = CombineHashes(hash, value);
   }
   return FinalizeHash(hash, (kBitsPerWord - 1));
 }
 
 
 #if defined(DEBUG)
@@ skipping 20 matching lines @@
 
 bool Instance::CheckAndCanonicalizeFields(Thread* thread,
                                           const char** error_str) const {
   if (GetClassId() >= kNumPredefinedCids) {
     // Iterate over all fields, canonicalize numbers and strings, expect all
     // other instances to be canonical otherwise report error (return false).
     Zone* zone = thread->zone();
     Object& obj = Object::Handle(zone);
     const intptr_t instance_size = SizeFromClass();
     ASSERT(instance_size != 0);
-    for (intptr_t offset = Instance::NextFieldOffset();
-         offset < instance_size;
+    for (intptr_t offset = Instance::NextFieldOffset(); offset < instance_size;
          offset += kWordSize) {
       obj = *this->FieldAddrAtOffset(offset);
       if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
         if (obj.IsNumber() || obj.IsString()) {
           obj = Instance::Cast(obj).CheckAndCanonicalize(thread, NULL);
           ASSERT(!obj.IsNull());
           this->SetFieldAtOffset(offset, obj);
         } else {
           ASSERT(error_str != NULL);
           char* chars = OS::SCreate(zone, "field: %s\n", obj.ToCString());
@@ skipping 73 matching lines @@
       // Type is not parameterized.
       if (!type.IsCanonical()) {
         type ^= type.Canonicalize();
         signature.SetSignatureType(type);
       }
       return type.raw();
     }
     const Class& scope_cls = Class::Handle(type.type_class());
     ASSERT(scope_cls.NumTypeArguments() > 0);
     TypeArguments& type_arguments = TypeArguments::Handle(GetTypeArguments());
-    type = Type::New(
-        scope_cls, type_arguments, TokenPosition::kNoSource, Heap::kNew);
+    type = Type::New(scope_cls, type_arguments, TokenPosition::kNoSource,
+                     Heap::kNew);
     type.set_signature(signature);
     type.SetIsFinalized();
     type ^= type.Canonicalize();
     return type.raw();
   }
   Type& type = Type::Handle();
   if (!cls.IsGeneric()) {
     type = cls.CanonicalType();
   }
   if (type.IsNull()) {
@@ skipping 35 matching lines @@
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsTypeRef());  // Must be dereferenced at compile time.
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, clazz());
   if (cls.IsClosureClass()) {
-    if (other.IsObjectType() ||
-        other.IsDartFunctionType() ||
+    if (other.IsObjectType() || other.IsDartFunctionType() ||
         other.IsDartClosureType()) {
       return true;
     }
     Function& other_signature = Function::Handle(zone);
     TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
     // Note that we may encounter a bound error in checked mode.
     if (!other.IsInstantiated()) {
       AbstractType& instantiated_other = AbstractType::Handle(
-          zone, other.InstantiateFrom(other_instantiator, bound_error,
-                                      NULL, NULL, Heap::kOld));
+          zone, other.InstantiateFrom(other_instantiator, bound_error, NULL,
+                                      NULL, Heap::kOld));
       if ((bound_error != NULL) && !bound_error->IsNull()) {
         ASSERT(Isolate::Current()->type_checks());
         return false;
       }
       if (instantiated_other.IsTypeRef()) {
         instantiated_other = TypeRef::Cast(instantiated_other).type();
       }
       if (instantiated_other.IsDynamicType() ||
           instantiated_other.IsObjectType() ||
           instantiated_other.IsDartFunctionType()) {
         return true;
       }
       if (!instantiated_other.IsFunctionType()) {
         return false;
       }
       other_signature = Type::Cast(instantiated_other).signature();
       other_type_arguments = instantiated_other.arguments();
     } else {
       if (!other.IsFunctionType()) {
         return false;
       }
       other_signature = Type::Cast(other).signature();
       other_type_arguments = other.arguments();
     }
     const Function& signature =
         Function::Handle(zone, Closure::Cast(*this).function());
     const TypeArguments& type_arguments =
         TypeArguments::Handle(zone, GetTypeArguments());
-    return signature.IsSubtypeOf(type_arguments,
-                                 other_signature,
-                                 other_type_arguments,
-                                 bound_error,
-                                 Heap::kOld);
+    return signature.IsSubtypeOf(type_arguments, other_signature,
+                                 other_type_arguments, bound_error, Heap::kOld);
   }
   TypeArguments& type_arguments = TypeArguments::Handle(zone);
   if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
     ASSERT(type_arguments.IsNull() || type_arguments.IsCanonical());
     // The number of type arguments in the instance must be greater or equal to
     // the number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a subclass of the class
     // defining the closure. Truncating the vector to the correct length on
@@ skipping 18 matching lines @@
       instantiated_other = TypeRef::Cast(instantiated_other).type();
     }
     if (instantiated_other.IsDynamicType()) {
       return true;
     }
   }
   other_type_arguments = instantiated_other.arguments();
   const bool other_is_dart_function = instantiated_other.IsDartFunctionType();
   if (other_is_dart_function || instantiated_other.IsFunctionType()) {
     // Check if this instance understands a call() method of a compatible type.
-    Function& call = Function::Handle(zone,
-        cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
+    Function& call = Function::Handle(
+        zone, cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
     if (call.IsNull()) {
       // Walk up the super_class chain.
       Class& super_cls = Class::Handle(zone, cls.SuperClass());
       while (!super_cls.IsNull() && call.IsNull()) {
         call = super_cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
         super_cls = super_cls.SuperClass();
       }
     }
     if (!call.IsNull()) {
       if (other_is_dart_function) {
         return true;
       }
-      const Function& other_signature = Function::Handle(
-          zone, Type::Cast(instantiated_other).signature());
-      if (call.IsSubtypeOf(type_arguments,
-                           other_signature,
-                           other_type_arguments,
-                           bound_error,
-                           Heap::kOld)) {
+      const Function& other_signature =
+          Function::Handle(zone, Type::Cast(instantiated_other).signature());
+      if (call.IsSubtypeOf(type_arguments, other_signature,
+                           other_type_arguments, bound_error, Heap::kOld)) {
         return true;
       }
     }
   }
   if (!instantiated_other.IsType()) {
     return false;
   }
   other_class = instantiated_other.type_class();
   return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
                          bound_error, NULL, Heap::kOld);
@@ skipping 172 matching lines @@
   } else {
     if (IsClosure()) {
       return Closure::Cast(*this).ToCString();
     }
     const Class& cls = Class::Handle(clazz());
     TypeArguments& type_arguments = TypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
-    const Type& type = Type::Handle(
-        Type::New(cls, type_arguments, TokenPosition::kNoSource));
+    const Type& type =
+        Type::Handle(Type::New(cls, type_arguments, TokenPosition::kNoSource));
     const String& type_name = String::Handle(type.UserVisibleName());
-    return OS::SCreate(Thread::Current()->zone(),
-        "Instance of '%s'", type_name.ToCString());
+    return OS::SCreate(Thread::Current()->zone(), "Instance of '%s'",
+                       type_name.ToCString());
   }
 }
 
 
 bool AbstractType::IsResolved() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
@@ skipping 25 matching lines @@
 }
 
 
 RawUnresolvedClass* AbstractType::unresolved_class() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return UnresolvedClass::null();
 }
 
 
-RawTypeArguments* AbstractType::arguments() const  {
+RawTypeArguments* AbstractType::arguments() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 void AbstractType::set_arguments(const TypeArguments& value) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
 }
@@ skipping 98 matching lines @@
 }
 
 
 RawAbstractType* AbstractType::CloneUnfinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-RawAbstractType* AbstractType::CloneUninstantiated(
-    const Class& new_owner, TrailPtr trail) const {
+RawAbstractType* AbstractType::CloneUninstantiated(const Class& new_owner,
+                                                   TrailPtr trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize(TrailPtr trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
@@ skipping 76 matching lines @@
   (*trail)->Add(buddy);
   return false;
 }
 
 
 RawString* AbstractType::BuildName(NameVisibility name_visibility) const {
   ASSERT(name_visibility != kScrubbedName);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   if (IsBoundedType()) {
-    const AbstractType& type = AbstractType::Handle(zone,
-        BoundedType::Cast(*this).type());
+    const AbstractType& type =
+        AbstractType::Handle(zone, BoundedType::Cast(*this).type());
     if (name_visibility == kUserVisibleName) {
       return type.BuildName(kUserVisibleName);
     }
     GrowableHandlePtrArray<const String> pieces(zone, 5);
     String& type_name = String::Handle(zone, type.BuildName(kInternalName));
     pieces.Add(type_name);
     pieces.Add(Symbols::SpaceExtendsSpace());
     // Build the bound name without causing divergence.
-    const AbstractType& bound = AbstractType::Handle(zone,
-        BoundedType::Cast(*this).bound());
+    const AbstractType& bound =
+        AbstractType::Handle(zone, BoundedType::Cast(*this).bound());
     String& bound_name = String::Handle(zone);
     if (bound.IsTypeParameter()) {
       bound_name = TypeParameter::Cast(bound).name();
       pieces.Add(bound_name);
     } else if (bound.IsType()) {
       const Class& cls = Class::Handle(zone, Type::Cast(bound).type_class());
       bound_name = cls.Name();
       pieces.Add(bound_name);
       if (Type::Cast(bound).arguments() != TypeArguments::null()) {
         pieces.Add(Symbols::OptimizedOut());
       }
     } else {
       pieces.Add(Symbols::OptimizedOut());
     }
     return Symbols::FromConcatAll(thread, pieces);
   }
   if (IsTypeParameter()) {
     return TypeParameter::Cast(*this).name();
   }
   // If the type is still being finalized, we may be reporting an error about
   // a malformed type, so proceed with caution.
   const TypeArguments& args = TypeArguments::Handle(zone, arguments());
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle(zone);
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   Class& cls = Class::Handle(zone);
   if (IsFunctionType()) {
     cls = type_class();
-    const Function& signature_function = Function::Handle(zone,
-        Type::Cast(*this).signature());
+    const Function& signature_function =
+        Function::Handle(zone, Type::Cast(*this).signature());
     if (!cls.IsTypedefClass() ||
         (cls.signature_function() != signature_function.raw())) {
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         return signature_function.UserVisibleSignature();
       }
       return signature_function.InstantiatedSignatureFrom(args,
                                                           name_visibility);
     }
     class_name = cls.Name();  // Typedef name.
     // We may be reporting an error about a malformed function type. In that
@@ skipping 45 matching lines @@
     class_name = UnresolvedClass::Handle(zone, unresolved_class()).Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   GrowableHandlePtrArray<const String> pieces(zone, 4);
   pieces.Add(class_name);
   if ((num_type_params == 0) ||
       args.IsRaw(first_type_param_index, num_type_params)) {
     // Do nothing.
   } else {
-    const String& args_name = String::Handle(zone,
-        args.SubvectorName(first_type_param_index,
-                           num_type_params,
-                           name_visibility));
+    const String& args_name = String::Handle(
+        zone, args.SubvectorName(first_type_param_index, num_type_params,
+                                 name_visibility));
     pieces.Add(args_name);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 RawString* AbstractType::ClassName() const {
   ASSERT(!IsFunctionType());
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
 
 
 bool AbstractType::IsDynamicType() const {
   if (IsCanonical()) {
     return raw() == Object::dynamic_type().raw();
   }
   return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
 }
 
 
 bool AbstractType::IsVoidType() const {
-    return raw() == Object::void_type().raw();
+  return raw() == Object::void_type().raw();
 }
 
 
 bool AbstractType::IsNullType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Isolate::Current()->object_store()->null_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Isolate::Current()->object_store()->null_class());
 }
 
 
 bool AbstractType::IsBoolType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Isolate::Current()->object_store()->bool_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Isolate::Current()->object_store()->bool_class());
 }
 
 
 bool AbstractType::IsIntType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::IntType()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::IntType()).type_class());
 }
 
 
 bool AbstractType::IsDoubleType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Double()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::Double()).type_class());
 }
 
 
 bool AbstractType::IsFloat32x4Type() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Float32x4()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::Float32x4()).type_class());
 }
 
 
 bool AbstractType::IsFloat64x2Type() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Float64x2()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::Float64x2()).type_class());
 }
 
 
 bool AbstractType::IsInt32x4Type() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Int32x4()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::Int32x4()).type_class());
 }
 
 
 bool AbstractType::IsNumberType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::Number()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::Number()).type_class());
 }
 
 
 bool AbstractType::IsSmiType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::SmiType()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::SmiType()).type_class());
 }
 
 
 bool AbstractType::IsStringType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::StringType()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::StringType()).type_class());
 }
 
 
 bool AbstractType::IsDartFunctionType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::DartFunctionType()).type_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Type::Handle(Type::DartFunctionType()).type_class());
 }
 
 
 bool AbstractType::IsDartClosureType() const {
-  return !IsFunctionType() &&
-      HasResolvedTypeClass() &&
-      (type_class() == Isolate::Current()->object_store()->closure_class());
+  return !IsFunctionType() && HasResolvedTypeClass() &&
+         (type_class() == Isolate::Current()->object_store()->closure_class());
 }
 
 
 bool AbstractType::TypeTest(TypeTestKind test_kind,
                             const AbstractType& other,
                             Error* bound_error,
                             TrailPtr bound_trail,
                             Heap::Space space) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
@@ skipping 39 matching lines @@
     // Bound checking at run time occurs when allocating an instance of a
     // generic bounded type using a valid instantiator. The instantiator is
     // the type of an instance successfully allocated, i.e. not containing
     // unchecked bounds anymore.
     // Therefore, when performing a type test at compile time (what is happening
     // here), it is safe to ignore the bounds, since they will not exist at run
     // time anymore.
     if (IsBoundedType()) {
       const AbstractType& bounded_type =
           AbstractType::Handle(zone, BoundedType::Cast(*this).type());
-      return bounded_type.TypeTest(test_kind,
-                                   other,
-                                   bound_error,
-                                   bound_trail,
+      return bounded_type.TypeTest(test_kind, other, bound_error, bound_trail,
                                    space);
     }
     const AbstractType& other_bounded_type =
         AbstractType::Handle(zone, BoundedType::Cast(other).type());
-    return TypeTest(test_kind,
-                    other_bounded_type,
-                    bound_error,
-                    bound_trail,
+    return TypeTest(test_kind, other_bounded_type, bound_error, bound_trail,
                     space);
   }
   // Type parameters cannot be handled by Class::TypeTest().
   // When comparing two uninstantiated function types, one returning type
   // parameter K, the other returning type parameter V, we cannot assume that K
   // is a subtype of V, or vice versa. We only return true if K equals V, as
   // defined by TypeParameter::Equals.
   // The same rule applies when checking the upper bound of a still
   // uninstantiated type at compile time. Returning false will defer the test
   // to run time.
@@ skipping 31 matching lines @@
   if (other_is_dart_function_type || other.IsFunctionType()) {
     if (IsFunctionType()) {
       if (other_is_dart_function_type) {
         return true;
       }
       const Function& other_fun =
           Function::Handle(zone, Type::Cast(other).signature());
       // Check for two function types.
       const Function& fun =
           Function::Handle(zone, Type::Cast(*this).signature());
-      return fun.TypeTest(test_kind,
-                          TypeArguments::Handle(zone, arguments()),
-                          other_fun,
-                          TypeArguments::Handle(zone, other.arguments()),
-                          bound_error,
-                          space);
+      return fun.TypeTest(
+          test_kind, TypeArguments::Handle(zone, arguments()), other_fun,
+          TypeArguments::Handle(zone, other.arguments()), bound_error, space);
     }
     // Check if type S has a call() method of function type T.
-    Function& function = Function::Handle(zone,
-        type_cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
+    Function& function = Function::Handle(
+        zone, type_cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
     if (function.IsNull()) {
       // Walk up the super_class chain.
       Class& cls = Class::Handle(zone, type_cls.SuperClass());
       while (!cls.IsNull() && function.IsNull()) {
         function = cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
         cls = cls.SuperClass();
       }
     }
     if (!function.IsNull()) {
       if (other_is_dart_function_type ||
-          function.TypeTest(test_kind,
-                            TypeArguments::Handle(zone, arguments()),
-                            Function::Handle(
-                                zone, Type::Cast(other).signature()),
-                            TypeArguments::Handle(zone, other.arguments()),
-                            bound_error,
-                            space)) {
+          function.TypeTest(
+              test_kind, TypeArguments::Handle(zone, arguments()),
+              Function::Handle(zone, Type::Cast(other).signature()),
+              TypeArguments::Handle(zone, other.arguments()), bound_error,
+              space)) {
         return true;
       }
     }
   }
   if (IsFunctionType()) {
     return false;
   }
-  return type_cls.TypeTest(test_kind,
-                           TypeArguments::Handle(zone, arguments()),
+  return type_cls.TypeTest(test_kind, TypeArguments::Handle(zone, arguments()),
                            Class::Handle(zone, other.type_class()),
                            TypeArguments::Handle(zone, other.arguments()),
-                           bound_error,
-                           bound_trail,
-                           space);
+                           bound_error, bound_trail, space);
 }
 
 
 intptr_t AbstractType::Hash() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
 
@@ skipping 82 matching lines @@
 RawType* Type::DartFunctionType() {
   return Isolate::Current()->object_store()->function_type();
 }
 
 
 RawType* Type::NewNonParameterizedType(const Class& type_class) {
   ASSERT(type_class.NumTypeArguments() == 0);
   Type& type = Type::Handle(type_class.CanonicalType());
   if (type.IsNull()) {
     const TypeArguments& no_type_arguments = TypeArguments::Handle();
-    type ^= Type::New(Object::Handle(type_class.raw()),
-                      no_type_arguments,
+    type ^= Type::New(Object::Handle(type_class.raw()), no_type_arguments,
                       TokenPosition::kNoSource);
     type.SetIsFinalized();
     type ^= type.Canonicalize();
   }
   ASSERT(type.IsFinalized());
   return type.raw();
 }
 
 
 void Type::SetIsFinalized() const {
@@ skipping 180 matching lines @@
   // occur during finalization and bounds checking. Return the type unchanged.
   if (arguments() == instantiator_type_arguments.raw()) {
     return raw();
   }
   // Note that the type class has to be resolved at this time, but not
   // necessarily finalized yet. We may be checking bounds at compile time or
   // finalizing the type argument vector of a recursive type.
   const Class& cls = Class::Handle(zone, type_class());
   TypeArguments& type_arguments = TypeArguments::Handle(zone, arguments());
   ASSERT(type_arguments.Length() == cls.NumTypeArguments());
-  type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
-                                                  bound_error,
-                                                  instantiation_trail,
-                                                  bound_trail,
-                                                  space);
+  type_arguments =
+      type_arguments.InstantiateFrom(instantiator_type_arguments, bound_error,
+                                     instantiation_trail, bound_trail, space);
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators. Allocate a new instantiated version of it.
   const Type& instantiated_type =
       Type::Handle(zone, Type::New(cls, type_arguments, token_pos(), space));
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     instantiated_type.set_error(bound_error);
   }
   // Preserve the signature if this type represents a function type.
@@ skipping 13 matching lines @@
 }
 
 
 bool Type::IsEquivalent(const Instance& other, TrailPtr trail) const {
   ASSERT(!IsNull());
   if (raw() == other.raw()) {
     return true;
   }
   if (other.IsTypeRef()) {
     // Unfold right hand type. Divergence is controlled by left hand type.
-    const AbstractType& other_ref_type = AbstractType::Handle(
-        TypeRef::Cast(other).type());
+    const AbstractType& other_ref_type =
+        AbstractType::Handle(TypeRef::Cast(other).type());
     ASSERT(!other_ref_type.IsTypeRef());
     return IsEquivalent(other_ref_type, trail);
   }
   if (!other.IsType()) {
     return false;
   }
   const Type& other_type = Type::Cast(other);
   if (IsFunctionType() != other_type.IsFunctionType()) {
     return false;
   }
@@ skipping 17 matching lines @@
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   if (arguments() != other_type.arguments()) {
     const Class& cls = Class::Handle(zone, type_class());
     const intptr_t num_type_params = cls.NumTypeParameters(thread);
     // Shortcut unnecessary handle allocation below if non-generic.
     if (num_type_params > 0) {
       const intptr_t num_type_args = cls.NumTypeArguments();
       const intptr_t from_index = num_type_args - num_type_params;
       const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
-      const TypeArguments& other_type_args = TypeArguments::Handle(
-          zone, other_type.arguments());
+      const TypeArguments& other_type_args =
+          TypeArguments::Handle(zone, other_type.arguments());
       if (type_args.IsNull()) {
         // Ignore from_index.
         if (!other_type_args.IsRaw(0, num_type_args)) {
           return false;
         }
       } else if (other_type_args.IsNull()) {
         // Ignore from_index.
         if (!type_args.IsRaw(0, num_type_args)) {
           return false;
         }
-      } else if (!type_args.IsSubvectorEquivalent(other_type_args,
-                                                  from_index,
-                                                  num_type_params,
-                                                  trail)) {
+      } else if (!type_args.IsSubvectorEquivalent(other_type_args, from_index,
+                                                  num_type_params, trail)) {
         return false;
       }
 #ifdef DEBUG
       if (from_index > 0) {
         // Verify that the type arguments of the super class match, since they
         // depend solely on the type parameters that were just verified to
         // match.
         ASSERT(type_args.Length() >= (from_index + num_type_params));
         ASSERT(other_type_args.Length() >= (from_index + num_type_params));
         AbstractType& type_arg = AbstractType::Handle(zone);
@@ skipping 17 matching lines @@
   if (!IsFunctionType()) {
     return true;
   }
   ASSERT(Type::Cast(other).IsFunctionType());
   // Equal function types must have equal signature types and equal optional
   // named arguments.
   if (signature() == other_type.signature()) {
     return true;
   }
   const Function& sig_fun = Function::Handle(zone, signature());
-  const Function& other_sig_fun = Function::Handle(
-      zone, other_type.signature());
+  const Function& other_sig_fun =
+      Function::Handle(zone, other_type.signature());
 
   // Compare number of function parameters.
   const intptr_t num_fixed_params = sig_fun.num_fixed_parameters();
   const intptr_t other_num_fixed_params = other_sig_fun.num_fixed_parameters();
   if (num_fixed_params != other_num_fixed_params) {
     return false;
   }
   const intptr_t num_opt_pos_params = sig_fun.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_pos_params =
       other_sig_fun.NumOptionalPositionalParameters();
@@ skipping 46 matching lines @@
 bool Type::IsRecursive() const {
   return TypeArguments::Handle(arguments()).IsRecursive();
 }
 
 
 RawAbstractType* Type::CloneUnfinalized() const {
   ASSERT(IsResolved());
   if (IsFinalized()) {
     return raw();
   }
-  ASSERT(!IsMalformed());  // Malformed types are finalized.
+  ASSERT(!IsMalformed());       // Malformed types are finalized.
   ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
   Zone* zone = Thread::Current()->zone();
   const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
   const TypeArguments& type_args_clone =
       TypeArguments::Handle(zone, type_args.CloneUnfinalized());
   if (type_args_clone.raw() == type_args.raw()) {
     return raw();
   }
-  const Type& clone = Type::Handle(zone,
+  const Type& clone = Type::Handle(
+      zone,
       Type::New(Class::Handle(zone, type_class()), type_args, token_pos()));
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     clone.set_error(bound_error);
   }
   // Clone the signature if this type represents a function type.
   Function& fun = Function::Handle(zone, signature());
   if (!fun.IsNull()) {
     const Class& owner = Class::Handle(zone, fun.Owner());
-    Function& fun_clone = Function::Handle(zone,
-        Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
+    Function& fun_clone = Function::Handle(
+        zone, Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUnfinalized();
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
-    fun_clone.set_parameter_types(Array::Handle(Array::New(num_params,
-                                                           Heap::kOld)));
+    fun_clone.set_parameter_types(
+        Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
       type = fun.ParameterTypeAt(i);
       type = type.CloneUnfinalized();
       fun_clone.SetParameterTypeAt(i, type);
     }
     fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
     clone.set_signature(fun_clone);
   }
   clone.SetIsResolved();
   return clone.raw();
@@ skipping 38 matching lines @@
       const TypeArguments& decl_type_args =
           TypeArguments::Handle(zone, decl_type.arguments());
       ASSERT(type_args.Equals(decl_type_args));
 #endif  // DEBUG
       decl_type = new_owner.DeclarationType();
       ASSERT(decl_type.IsFinalized());
       type_args = decl_type.arguments();
       clone.set_arguments(type_args);
       type_args_cloned = true;
     }
-    Function& fun_clone = Function::Handle(zone,
+    Function& fun_clone = Function::Handle(
+        zone,
         Function::NewSignatureFunction(new_owner, TokenPosition::kNoSource));
     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUninstantiated(new_owner, trail);
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
-    fun_clone.set_parameter_types(Array::Handle(Array::New(num_params,
-                                                           Heap::kOld)));
+    fun_clone.set_parameter_types(
+        Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
       type = fun.ParameterTypeAt(i);
       type = type.CloneUninstantiated(new_owner, trail);
       fun_clone.SetParameterTypeAt(i, type);
     }
     fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
     clone.set_signature(fun_clone);
   }
   if (!type_args_cloned) {
     // Upper bounds of uninstantiated type arguments may form a cycle.
@@ skipping 102 matching lines @@
         Function& sig_fun = Function::Handle(
             zone,
             Function::NewSignatureFunction(cls, TokenPosition::kNoSource));
         type = fun.result_type();
         type = type.Canonicalize(trail);
         sig_fun.set_result_type(type);
         const intptr_t num_params = fun.NumParameters();
         sig_fun.set_num_fixed_parameters(fun.num_fixed_parameters());
         sig_fun.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                          fun.HasOptionalPositionalParameters());
-        sig_fun.set_parameter_types(Array::Handle(Array::New(num_params,
-                                                             Heap::kOld)));
+        sig_fun.set_parameter_types(
+            Array::Handle(Array::New(num_params, Heap::kOld)));
         for (intptr_t i = 0; i < num_params; i++) {
           type = fun.ParameterTypeAt(i);
           type = type.Canonicalize(trail);
           sig_fun.SetParameterTypeAt(i, type);
         }
         sig_fun.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
         set_signature(sig_fun);
       }
     }
 
@@ skipping 132 matching lines @@
 }
 
 
 void Type::set_arguments(const TypeArguments& value) const {
   ASSERT(!IsCanonical());
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New(Heap::Space space) {
-  RawObject* raw = Object::Allocate(Type::kClassId,
-                                    Type::InstanceSize(),
-                                    space);
+  RawObject* raw =
+      Object::Allocate(Type::kClassId, Type::InstanceSize(), space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
                    const TypeArguments& arguments,
                    TokenPosition token_pos,
                    Heap::Space space) {
   const Type& result = Type::Handle(Type::New(space));
   if (clazz.IsClass()) {
@@ skipping 30 matching lines @@
   Class& cls = Class::Handle(zone);
   const char* class_name;
   if (HasResolvedTypeClass()) {
     cls = type_class();
     class_name = String::Handle(zone, cls.Name()).ToCString();
   } else {
     class_name = UnresolvedClass::Handle(zone, unresolved_class()).ToCString();
   }
   if (IsFunctionType()) {
     const Function& sig_fun = Function::Handle(zone, signature());
-    const String& sig = IsFinalized() ?
-        String::Handle(zone, sig_fun.InstantiatedSignatureFrom(type_args,
-                                                               kInternalName)) :
-        String::Handle(zone, sig_fun.Signature());
+    const String& sig =
+        IsFinalized() ? String::Handle(zone, sig_fun.InstantiatedSignatureFrom(
+                                                 type_args, kInternalName))
+                      : String::Handle(zone, sig_fun.Signature());
     if (cls.IsClosureClass()) {
       ASSERT(type_args.IsNull());
-      return OS::SCreate(zone, "%sFunction Type: %s",
-                         unresolved, sig.ToCString());
+      return OS::SCreate(zone, "%sFunction Type: %s", unresolved,
+                         sig.ToCString());
     }
     return OS::SCreate(zone, "%s Function Type: %s (class: %s, args: %s)",
-                       unresolved,
-                       sig.ToCString(),
-                       class_name,
-                       args_cstr);
+                       unresolved, sig.ToCString(), class_name, args_cstr);
   }
   if (type_args.IsNull()) {
     return OS::SCreate(zone, "%sType: class '%s'", unresolved, class_name);
   } else if (IsResolved() && IsFinalized() && IsRecursive()) {
     const intptr_t hash = Hash();
     return OS::SCreate(zone, "Type: (@%p H%" Px ") class '%s', args:[%s]",
                        raw(), hash, class_name, args_cstr);
   } else {
-    return OS::SCreate(zone, "%sType: class '%s', args:[%s]",
-                       unresolved, class_name, args_cstr);
+    return OS::SCreate(zone, "%sType: class '%s', args:[%s]", unresolved,
+                       class_name, args_cstr);
   }
 }
 
 
 bool TypeRef::IsInstantiated(TrailPtr trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
   }
   return AbstractType::Handle(type()).IsInstantiated(trail);
 }
@@ skipping 23 matching lines @@
   instantiated_type_ref ^= OnlyBuddyInTrail(instantiation_trail);
   if (!instantiated_type_ref.IsNull()) {
     return instantiated_type_ref.raw();
   }
   instantiated_type_ref = TypeRef::New();
   AddOnlyBuddyToTrail(&instantiation_trail, instantiated_type_ref);
 
   AbstractType& ref_type = AbstractType::Handle(type());
   ASSERT(!ref_type.IsTypeRef());
   AbstractType& instantiated_ref_type = AbstractType::Handle();
-  instantiated_ref_type = ref_type.InstantiateFrom(
-      instantiator_type_arguments,
-      bound_error,
-      instantiation_trail,
-      bound_trail,
-      space);
+  instantiated_ref_type =
+      ref_type.InstantiateFrom(instantiator_type_arguments, bound_error,
+                               instantiation_trail, bound_trail, space);
   ASSERT(!instantiated_ref_type.IsTypeRef());
   instantiated_type_ref.set_type(instantiated_ref_type);
   return instantiated_type_ref.raw();
 }
 
 
 RawTypeRef* TypeRef::CloneUninstantiated(const Class& new_owner,
                                          TrailPtr trail) const {
   TypeRef& cloned_type_ref = TypeRef::Handle();
   cloned_type_ref ^= OnlyBuddyInTrail(trail);
@@ skipping 65 matching lines @@
 
 intptr_t TypeRef::Hash() const {
   // Do not calculate the hash of the referenced type to avoid divergence.
   const uint32_t result =
       Class::Handle(AbstractType::Handle(type()).type_class()).id();
   return FinalizeHash(result, kHashBits);
 }
 
 
 RawTypeRef* TypeRef::New() {
-  RawObject* raw = Object::Allocate(TypeRef::kClassId,
-                                    TypeRef::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw =
+      Object::Allocate(TypeRef::kClassId, TypeRef::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawTypeRef*>(raw);
 }
 
 
 RawTypeRef* TypeRef::New(const AbstractType& type) {
   const TypeRef& result = TypeRef::Handle(TypeRef::New());
   result.set_type(type);
   return result.raw();
 }
 
 
 const char* TypeRef::ToCString() const {
-  const char* type_cstr = String::Handle(Class::Handle(
-      type_class()).Name()).ToCString();
+  const char* type_cstr =
+      String::Handle(Class::Handle(type_class()).Name()).ToCString();
   AbstractType& ref_type = AbstractType::Handle(type());
   if (ref_type.IsFinalized()) {
     const intptr_t hash = ref_type.Hash();
     return OS::SCreate(Thread::Current()->zone(),
-        "TypeRef: %s<...> (@%p H%" Px ")", type_cstr, ref_type.raw(), hash);
+                       "TypeRef: %s<...> (@%p H%" Px ")", type_cstr,
+                       ref_type.raw(), hash);
   } else {
-    return OS::SCreate(Thread::Current()->zone(),
-        "TypeRef: %s<...>", type_cstr);
+    return OS::SCreate(Thread::Current()->zone(), "TypeRef: %s<...>",
+                       type_cstr);
   }
 }
 
 
 void TypeParameter::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (other.IsTypeRef()) {
     // Unfold right hand type. Divergence is controlled by left hand type.
-    const AbstractType& other_ref_type = AbstractType::Handle(
-        TypeRef::Cast(other).type());
+    const AbstractType& other_ref_type =
+        AbstractType::Handle(TypeRef::Cast(other).type());
     ASSERT(!other_ref_type.IsTypeRef());
     return IsEquivalent(other_ref_type, trail);
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
   if (parameterized_class() != other_type_param.parameterized_class()) {
     return false;
   }
@@ skipping 54 matching lines @@
 RawAbstractType* TypeParameter::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
-  const AbstractType& type_arg = AbstractType::Handle(
-      instantiator_type_arguments.TypeAt(index()));
+  const AbstractType& type_arg =
+      AbstractType::Handle(instantiator_type_arguments.TypeAt(index()));
   // There is no need to canonicalize the instantiated type parameter, since all
   // type arguments are canonicalized at type finalization time. It would be too
   // early to canonicalize the returned type argument here, since instantiation
   // not only happens at run time, but also during type finalization.
 
   // If the instantiated type parameter type_arg is a BoundedType, it means that
   // it is still uninstantiated and that we are instantiating at finalization
   // time (i.e. compile time).
   // Indeed, the instantiator (type arguments of an instance) is always
   // instantiated at run time and any bounds were checked during allocation.
@@ skipping 19 matching lines @@
   }
 
   if (bounded_type.IsSubtypeOf(upper_bound, bound_error, bound_trail, space)) {
     return true;
   }
   // Set bound_error if the caller is interested and if this is the first error.
   if ((bound_error != NULL) && bound_error->IsNull()) {
     // Report the bound error only if both the bounded type and the upper bound
     // are instantiated. Otherwise, we cannot tell yet it is a bound error.
     if (bounded_type.IsInstantiated() && upper_bound.IsInstantiated()) {
-      const String& bounded_type_name = String::Handle(
-          bounded_type.UserVisibleName());
-      const String& upper_bound_name = String::Handle(
-          upper_bound.UserVisibleName());
+      const String& bounded_type_name =
+          String::Handle(bounded_type.UserVisibleName());
+      const String& upper_bound_name =
+          String::Handle(upper_bound.UserVisibleName());
       const AbstractType& declared_bound = AbstractType::Handle(bound());
-      const String& declared_bound_name = String::Handle(
-          declared_bound.UserVisibleName());
+      const String& declared_bound_name =
+          String::Handle(declared_bound.UserVisibleName());
       const String& type_param_name = String::Handle(UserVisibleName());
       const Class& cls = Class::Handle(parameterized_class());
       const String& class_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       // Since the bound may have been canonicalized, its token index is
       // meaningless, therefore use the token index of this type parameter.
       *bound_error = LanguageError::NewFormatted(
-          *bound_error,
-          script,
-          token_pos(),
-          Report::AtLocation,
-          Report::kMalboundedType,
-          Heap::kNew,
+          *bound_error, script, token_pos(), Report::AtLocation,
+          Report::kMalboundedType, Heap::kNew,
           "type parameter '%s' of class '%s' must extend bound '%s', "
           "but type argument '%s' is not a subtype of '%s' where\n%s%s",
-          type_param_name.ToCString(),
-          class_name.ToCString(),
-          declared_bound_name.ToCString(),
-          bounded_type_name.ToCString(),
+          type_param_name.ToCString(), class_name.ToCString(),
+          declared_bound_name.ToCString(), bounded_type_name.ToCString(),
           upper_bound_name.ToCString(),
           String::Handle(bounded_type.EnumerateURIs()).ToCString(),
           String::Handle(upper_bound.EnumerateURIs()).ToCString());
     }
   }
   return false;
 }
 
 
 RawAbstractType* TypeParameter::CloneUnfinalized() const {
   if (IsFinalized()) {
     return raw();
   }
   // No need to clone bound, as it is not part of the finalization state.
   return TypeParameter::New(Class::Handle(parameterized_class()),
-                            Function::Handle(parameterized_function()),
-                            index(),
+                            Function::Handle(parameterized_function()), index(),
                             String::Handle(name()),
-                            AbstractType::Handle(bound()),
-                            token_pos());
+                            AbstractType::Handle(bound()), token_pos());
 }
 
 
-RawAbstractType* TypeParameter::CloneUninstantiated(
-    const Class& new_owner, TrailPtr trail) const {
+RawAbstractType* TypeParameter::CloneUninstantiated(const Class& new_owner,
+                                                    TrailPtr trail) const {
   ASSERT(IsFinalized());
   TypeParameter& clone = TypeParameter::Handle();
   clone ^= OnlyBuddyInTrail(trail);
   if (!clone.IsNull()) {
     return clone.raw();
   }
   const Class& old_owner = Class::Handle(parameterized_class());
-  const intptr_t new_index = index() +
-      new_owner.NumTypeArguments() - old_owner.NumTypeArguments();
+  const intptr_t new_index =
+      index() + new_owner.NumTypeArguments() - old_owner.NumTypeArguments();
   AbstractType& upper_bound = AbstractType::Handle(bound());
   ASSERT(parameterized_function() == Function::null());
-  clone = TypeParameter::New(new_owner,
-                             Function::Handle(),
-                             new_index,
+  clone = TypeParameter::New(new_owner, Function::Handle(), new_index,
                              String::Handle(name()),
                              upper_bound,  // Not cloned yet.
                              token_pos());
   clone.SetIsFinalized();
   AddOnlyBuddyToTrail(&trail, clone);
   upper_bound = upper_bound.CloneUninstantiated(new_owner, trail);
   clone.set_bound(upper_bound);
   return clone.raw();
 }
 
@@ skipping 22 matching lines @@
   // identified by its class and index.
   result = CombineHashes(result, index());
   result = FinalizeHash(result, kHashBits);
   SetHash(result);
   return result;
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   RawObject* raw = Object::Allocate(TypeParameter::kClassId,
-                                    TypeParameter::InstanceSize(),
-                                    Heap::kOld);
+                                    TypeParameter::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
 RawTypeParameter* TypeParameter::New(const Class& parameterized_class,
                                      const Function& parameterized_function,
                                      intptr_t index,
                                      const String& name,
                                      const AbstractType& bound,
                                      TokenPosition token_pos) {
@@ skipping 29 matching lines @@
          (state == RawTypeParameter::kFinalizedUninstantiated));
   StoreNonPointer(&raw_ptr()->type_state_, state);
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* name_cstr = String::Handle(Name()).ToCString();
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   const char* bound_cstr = String::Handle(upper_bound.Name()).ToCString();
   if (IsFunctionTypeParameter()) {
-    const char* format = "TypeParameter: name %s; index: %d; parent_level: %d, "
+    const char* format =
+        "TypeParameter: name %s; index: %d; parent_level: %d, "
         "function: %s; bound: %s";
     const Function& function = Function::Handle(parameterized_function());
     const char* fun_cstr = String::Handle(function.name()).ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, index(),
-                               parent_level(), fun_cstr, bound_cstr) + 1;
+                               parent_level(), fun_cstr, bound_cstr) +
+                   1;
     char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, name_cstr, index(), parent_level(),
                 fun_cstr, bound_cstr);
     return chars;
   } else {
     const char* format =
         "TypeParameter: name %s; index: %d; class: %s; bound: %s";
     const Class& cls = Class::Handle(parameterized_class());
     const char* cls_cstr =
         cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
-    intptr_t len = OS::SNPrint(
-        NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
+    intptr_t len =
+        OS::SNPrint(NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) +
+        1;
     char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
     return chars;
   }
 }
 
 
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
@@ skipping 15 matching lines @@
 
 
 bool BoundedType::IsEquivalent(const Instance& other, TrailPtr trail) const {
   // BoundedType are not canonicalized, because their bound may get finalized
   // after the BoundedType is created and initialized.
   if (raw() == other.raw()) {
     return true;
   }
   if (other.IsTypeRef()) {
     // Unfold right hand type. Divergence is controlled by left hand type.
-    const AbstractType& other_ref_type = AbstractType::Handle(
-        TypeRef::Cast(other).type());
+    const AbstractType& other_ref_type =
+        AbstractType::Handle(TypeRef::Cast(other).type());
     ASSERT(!other_ref_type.IsTypeRef());
     return IsEquivalent(other_ref_type, trail);
   }
   if (!other.IsBoundedType()) {
     return false;
   }
   const BoundedType& other_bounded = BoundedType::Cast(other);
   if (type_parameter() != other_bounded.type_parameter()) {
     return false;
   }
   const AbstractType& this_type = AbstractType::Handle(type());
   const AbstractType& other_type = AbstractType::Handle(other_bounded.type());
   if (!this_type.IsEquivalent(other_type, trail)) {
     return false;
   }
   const AbstractType& this_bound = AbstractType::Handle(bound());
   const AbstractType& other_bound = AbstractType::Handle(other_bounded.bound());
-  return this_bound.IsFinalized() &&
-         other_bound.IsFinalized() &&
+  return this_bound.IsFinalized() && other_bound.IsFinalized() &&
          this_bound.Equals(other_bound);  // Different graph, do not pass trail.
 }
 
 
 bool BoundedType::IsRecursive() const {
   return AbstractType::Handle(type()).IsRecursive();
 }
 
 
 void BoundedType::set_type(const AbstractType& value) const {
-  ASSERT(value.IsFinalized() ||
-         value.IsBeingFinalized() ||
+  ASSERT(value.IsFinalized() || value.IsBeingFinalized() ||
          value.IsTypeParameter());
   ASSERT(!value.IsMalformed());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 void BoundedType::set_bound(const AbstractType& value) const {
   // The bound may still be unfinalized because of legal cycles.
   // It must be finalized before it is checked at run time, though.
   ASSERT(value.IsFinalized() || value.IsBeingFinalized());
@@ skipping 15 matching lines @@
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(IsFinalized());
   AbstractType& bounded_type = AbstractType::Handle(type());
   ASSERT(bounded_type.IsFinalized());
   AbstractType& instantiated_bounded_type =
       AbstractType::Handle(bounded_type.raw());
   if (!bounded_type.IsInstantiated()) {
     instantiated_bounded_type =
-        bounded_type.InstantiateFrom(instantiator_type_arguments,
-                                     bound_error,
-                                     instantiation_trail,
-                                     bound_trail,
-                                     space);
+        bounded_type.InstantiateFrom(instantiator_type_arguments, bound_error,
+                                     instantiation_trail, bound_trail, space);
     // In case types of instantiator_type_arguments are not finalized
     // (or instantiated), then the instantiated_bounded_type is not finalized
     // (or instantiated) either.
     // Note that instantiator_type_arguments must have the final length, though.
   }
-  if ((Isolate::Current()->type_checks()) &&
-      (bound_error != NULL) && bound_error->IsNull()) {
+  if ((Isolate::Current()->type_checks()) && (bound_error != NULL) &&
+      bound_error->IsNull()) {
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(upper_bound.IsFinalized());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());
     AbstractType& instantiated_upper_bound =
         AbstractType::Handle(upper_bound.raw());
     if (!upper_bound.IsInstantiated()) {
       instantiated_upper_bound =
-          upper_bound.InstantiateFrom(instantiator_type_arguments,
-                                      bound_error,
-                                      instantiation_trail,
-                                      bound_trail,
-                                      space);
+          upper_bound.InstantiateFrom(instantiator_type_arguments, bound_error,
+                                      instantiation_trail, bound_trail, space);
       // The instantiated_upper_bound may not be finalized or instantiated.
       // See comment above.
     }
     if (bound_error->IsNull()) {
       // Shortcut the F-bounded case where we have reached a fixpoint.
       if (instantiated_bounded_type.Equals(bounded_type) &&
           instantiated_upper_bound.Equals(upper_bound)) {
         return bounded_type.raw();
       }
       const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
       if (!instantiated_bounded_type.IsFinalized() ||
           !instantiated_upper_bound.IsFinalized() ||
           (!type_param.CheckBound(instantiated_bounded_type,
-                                  instantiated_upper_bound,
-                                  bound_error,
-                                  bound_trail,
-                                  space) &&
+                                  instantiated_upper_bound, bound_error,
+                                  bound_trail, space) &&
            bound_error->IsNull())) {
         // We cannot determine yet whether the bounded_type is below the
         // upper_bound, because one or both of them is still being finalized or
         // uninstantiated. For example, instantiated_bounded_type may be the
         // still unfinalized cloned type parameter of a mixin application class.
         ASSERT(instantiated_bounded_type.IsBeingFinalized() ||
                instantiated_upper_bound.IsBeingFinalized() ||
                !instantiated_bounded_type.IsInstantiated() ||
                !instantiated_upper_bound.IsInstantiated());
         // Postpone bound check by returning a new BoundedType with unfinalized
         // or partially instantiated bounded_type and upper_bound, but keeping
         // type_param.
-        instantiated_bounded_type = BoundedType::New(instantiated_bounded_type,
-                                                     instantiated_upper_bound,
-                                                     type_param);
+        instantiated_bounded_type = BoundedType::New(
+            instantiated_bounded_type, instantiated_upper_bound, type_param);
       }
     }
   }
   return instantiated_bounded_type.raw();
 }
 
 
 RawAbstractType* BoundedType::CloneUnfinalized() const {
   if (IsFinalized()) {
     return raw();
   }
   const AbstractType& bounded_type = AbstractType::Handle(type());
   const AbstractType& bounded_type_clone =
       AbstractType::Handle(bounded_type.CloneUnfinalized());
   if (bounded_type_clone.raw() == bounded_type.raw()) {
     return raw();
   }
   // No need to clone bound or type parameter, as they are not part of the
   // finalization state of this bounded type.
-  return BoundedType::New(bounded_type,
-                          AbstractType::Handle(bound()),
+  return BoundedType::New(bounded_type, AbstractType::Handle(bound()),
                           TypeParameter::Handle(type_parameter()));
 }
 
 
-RawAbstractType* BoundedType::CloneUninstantiated(
-    const Class& new_owner, TrailPtr trail) const {
+RawAbstractType* BoundedType::CloneUninstantiated(const Class& new_owner,
+                                                  TrailPtr trail) const {
   if (IsInstantiated()) {
     return raw();
   }
   AbstractType& bounded_type = AbstractType::Handle(type());
   bounded_type = bounded_type.CloneUninstantiated(new_owner, trail);
   AbstractType& upper_bound = AbstractType::Handle(bound());
   upper_bound = upper_bound.CloneUninstantiated(new_owner, trail);
-  TypeParameter& type_param =  TypeParameter::Handle(type_parameter());
+  TypeParameter& type_param = TypeParameter::Handle(type_parameter());
   type_param ^= type_param.CloneUninstantiated(new_owner, trail);
   return BoundedType::New(bounded_type, upper_bound, type_param);
 }
 
 
 RawString* BoundedType::EnumerateURIs() const {
   // The bound does not appear in the user visible name.
   return AbstractType::Handle(type()).EnumerateURIs();
 }
 
 
 intptr_t BoundedType::ComputeHash() const {
   uint32_t result = AbstractType::Handle(type()).Hash();
   // No need to include the hash of the bound, since the bound is defined by the
   // type parameter (modulo instantiation state).
-  result = CombineHashes(result,
-                         TypeParameter::Handle(type_parameter()).Hash());
+  result =
+      CombineHashes(result, TypeParameter::Handle(type_parameter()).Hash());
   result = FinalizeHash(result, kHashBits);
   SetHash(result);
   return result;
 }
 
 
 RawBoundedType* BoundedType::New() {
   RawObject* raw = Object::Allocate(BoundedType::kClassId,
-                                    BoundedType::InstanceSize(),
-                                    Heap::kOld);
+                                    BoundedType::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawBoundedType*>(raw);
 }
 
 
 RawBoundedType* BoundedType::New(const AbstractType& type,
                                  const AbstractType& bound,
                                  const TypeParameter& type_parameter) {
   const BoundedType& result = BoundedType::Handle(BoundedType::New());
   result.set_type(type);
   result.set_bound(bound);
   result.SetHash(0);
   result.set_type_parameter(type_parameter);
   return result.raw();
 }
 
 
 const char* BoundedType::ToCString() const {
   const char* format = "BoundedType: type %s; bound: %s; type param: %s of %s";
-  const char* type_cstr = String::Handle(AbstractType::Handle(
-      type()).Name()).ToCString();
-  const char* bound_cstr = String::Handle(AbstractType::Handle(
-      bound()).Name()).ToCString();
+  const char* type_cstr =
+      String::Handle(AbstractType::Handle(type()).Name()).ToCString();
+  const char* bound_cstr =
+      String::Handle(AbstractType::Handle(bound()).Name()).ToCString();
   const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
   const char* type_param_cstr = String::Handle(type_param.name()).ToCString();
   const Class& cls = Class::Handle(type_param.parameterized_class());
   const char* cls_cstr = String::Handle(cls.Name()).ToCString();
-  intptr_t len = OS::SNPrint(
-      NULL, 0, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr) + 1;
+  intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr, bound_cstr,
+                             type_param_cstr, cls_cstr) +
+                 1;
   char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(
-      chars, len, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr);
+  OS::SNPrint(chars, len, format, type_cstr, bound_cstr, type_param_cstr,
+              cls_cstr);
   return chars;
 }
 
 
 TokenPosition MixinAppType::token_pos() const {
   return AbstractType::Handle(MixinTypeAt(0)).token_pos();
 }
 
 
 intptr_t MixinAppType::Depth() const {
   return Array::Handle(mixin_types()).Length();
 }
 
 
 RawString* MixinAppType::Name() const {
   return String::New("MixinAppType");
 }
 
 
 const char* MixinAppType::ToCString() const {
   const char* format = "MixinAppType: super type: %s; first mixin type: %s";
-  const char* super_type_cstr = String::Handle(AbstractType::Handle(
-      super_type()).Name()).ToCString();
-  const char* first_mixin_type_cstr = String::Handle(AbstractType::Handle(
-      MixinTypeAt(0)).Name()).ToCString();
-  intptr_t len = OS::SNPrint(
-      NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
+  const char* super_type_cstr =
+      String::Handle(AbstractType::Handle(super_type()).Name()).ToCString();
+  const char* first_mixin_type_cstr =
+      String::Handle(AbstractType::Handle(MixinTypeAt(0)).Name()).ToCString();
+  intptr_t len =
+      OS::SNPrint(NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
   char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
 RawAbstractType* MixinAppType::MixinTypeAt(intptr_t depth) const {
   return AbstractType::RawCast(Array::Handle(mixin_types()).At(depth));
 }
 
 
 void MixinAppType::set_super_type(const AbstractType& value) const {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 void MixinAppType::set_mixin_types(const Array& value) const {
   StorePointer(&raw_ptr()->mixin_types_, value.raw());
 }
 
 
 RawMixinAppType* MixinAppType::New() {
   // MixinAppType objects do not survive finalization, so allocate
   // on new heap.
   RawObject* raw = Object::Allocate(MixinAppType::kClassId,
-                                    MixinAppType::InstanceSize(),
-                                    Heap::kOld);
+                                    MixinAppType::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawMixinAppType*>(raw);
 }
 
 
 RawMixinAppType* MixinAppType::New(const AbstractType& super_type,
                                    const Array& mixin_types) {
   const MixinAppType& result = MixinAppType::Handle(MixinAppType::New());
   result.set_super_type(super_type);
   result.set_mixin_types(mixin_types);
   return result.raw();
@@ skipping 20 matching lines @@
       const Class& cls = Class::Handle(zone, this->clazz());
       intptr_t index = 0;
       result ^= cls.LookupCanonicalBigint(zone, Bigint::Cast(*this), &index);
       if (!result.IsNull()) {
         return result.raw();
       }
       {
         SafepointMutexLocker ml(isolate->constant_canonicalization_mutex());
         // Retry lookup.
         {
-          result ^= cls.LookupCanonicalBigint(
-              zone, Bigint::Cast(*this), &index);
+          result ^=
+              cls.LookupCanonicalBigint(zone, Bigint::Cast(*this), &index);
           if (!result.IsNull()) {
             return result.raw();
           }
         }
 
         // The value needs to be added to the list. Grow the list if
         // it is full.
         result ^= this->raw();
         ASSERT((isolate == Dart::vm_isolate()) || !result.InVMHeap());
         if (result.IsNew()) {
@@ skipping 57 matching lines @@
   ASSERT(IsNull());
   return "NULL Integer";
 }
 
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
   // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
-    const Bigint& big = Bigint::Handle(
-        Bigint::NewFromCString(str.ToCString(), space));
+    const Bigint& big =
+        Bigint::Handle(Bigint::NewFromCString(str.ToCString(), space));
     ASSERT(!big.FitsIntoSmi());
     ASSERT(!big.FitsIntoInt64());
     return big.raw();
   }
   return Integer::New(value, space);
 }
 
 
 RawInteger* Integer::NewCanonical(const String& str) {
   // We are not supposed to have integers represented as two byte strings.
@@ skipping 122 matching lines @@
     const intptr_t right_value = Smi::Value(Smi::RawCast(other.raw()));
     switch (operation) {
       case Token::kADD:
         return Integer::New(left_value + right_value, space);
       case Token::kSUB:
         return Integer::New(left_value - right_value, space);
       case Token::kMUL: {
         if (Smi::kBits < 32) {
           // In 32-bit mode, the product of two Smis fits in a 64-bit result.
           return Integer::New(static_cast<int64_t>(left_value) *
-                              static_cast<int64_t>(right_value),
+                                  static_cast<int64_t>(right_value),
                               space);
         } else {
           // In 64-bit mode, the product of two signed integers fits in a
           // 64-bit result if the sum of the highest bits of their absolute
           // values is smaller than 62.
           ASSERT(sizeof(intptr_t) == sizeof(int64_t));
-          if ((Utils::HighestBit(left_value) +
-               Utils::HighestBit(right_value)) < 62) {
+          if ((Utils::HighestBit(left_value) + Utils::HighestBit(right_value)) <
+              62) {
             return Integer::New(left_value * right_value, space);
           }
         }
         // Perform a Bigint multiplication below.
         break;
       }
       case Token::kTRUNCDIV:
         return Integer::New(left_value / right_value, space);
       case Token::kMOD: {
         const intptr_t remainder = left_value % right_value;
@@ skipping 20 matching lines @@
         }
         break;
       }
       case Token::kSUB: {
         if (!Utils::WillSubOverflow(left_value, right_value)) {
           return Integer::New(left_value - right_value, space);
         }
         break;
       }
       case Token::kMUL: {
-        if ((Utils::HighestBit(left_value) +
-             Utils::HighestBit(right_value)) < 62) {
+        if ((Utils::HighestBit(left_value) + Utils::HighestBit(right_value)) <
+            62) {
           return Integer::New(left_value * right_value, space);
         }
         break;
       }
       case Token::kTRUNCDIV: {
         if ((left_value != Mint::kMinValue) || (right_value != -1)) {
           return Integer::New(left_value / right_value, space);
         }
         break;
       }
@@ skipping 14 matching lines @@
   }
   return Integer::null();  // Notify caller that a bigint operation is required.
 }
 
 
 static bool Are64bitOperands(const Integer& op1, const Integer& op2) {
   return !op1.IsBigint() && !op2.IsBigint();
 }
 
 
-RawInteger* Integer::BitOp(
-    Token::Kind kind, const Integer& other, Heap::Space space) const {
+RawInteger* Integer::BitOp(Token::Kind kind,
+                           const Integer& other,
+                           Heap::Space space) const {
   if (IsSmi() && other.IsSmi()) {
     intptr_t op1_value = Smi::Value(Smi::RawCast(raw()));
     intptr_t op2_value = Smi::Value(Smi::RawCast(other.raw()));
     intptr_t result = 0;
     switch (kind) {
       case Token::kBIT_AND:
         result = op1_value & op2_value;
         break;
       case Token::kBIT_OR:
         result = op1_value | op2_value;
@@ skipping 30 matching lines @@
                          Heap::Space space) const {
   intptr_t result = 0;
   const intptr_t left_value = Value();
   const intptr_t right_value = other.Value();
   ASSERT(right_value >= 0);
   switch (kind) {
     case Token::kSHL: {
       if ((left_value == 0) || (right_value == 0)) {
         return raw();
       }
-      { // Check for overflow.
+      {  // Check for overflow.
         int cnt = Utils::BitLength(left_value);
         if ((cnt + right_value) > Smi::kBits) {
           if ((cnt + right_value) > Mint::kBits) {
             return Bigint::NewFromShiftedInt64(left_value, right_value, space);
           } else {
             int64_t left_64 = left_value;
             return Integer::New(left_64 << right_value, space);
           }
         }
       }
@@ skipping 74 matching lines @@
   StoreNonPointer(&raw_ptr()->value_, value);
 }
 
 
 RawMint* Mint::New(int64_t val, Heap::Space space) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid(val));
   ASSERT(Isolate::Current()->object_store()->mint_class() != Class::null());
   Mint& result = Mint::Handle();
   {
-    RawObject* raw = Object::Allocate(Mint::kClassId,
-                                      Mint::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Mint::kClassId, Mint::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(val);
   return result.raw();
 }
 
 
 RawMint* Mint::NewCanonical(int64_t value) {
   // Do not allocate a Mint if Smi would do.
@@ skipping 119 matching lines @@
     return false;
   }
   return BitwiseEqualsToDouble(Double::Cast(other).value());
 }
 
 
 RawDouble* Double::New(double d, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->double_class() != Class::null());
   Double& result = Double::Handle();
   {
-    RawObject* raw = Object::Allocate(Double::kClassId,
-                                      Double::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Double::kClassId, Double::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(d);
   return result.raw();
 }
 
 
 RawDouble* Double::New(const String& str, Heap::Space space) {
   double double_value;
@@ skipping 43 matching lines @@
     return Double::Handle().raw();
   }
   return NewCanonical(double_value);
 }
 
 
 RawString* Number::ToString(Heap::Space space) const {
   // Refactoring can avoid Zone::Alloc and strlen, but gains are insignificant.
   const char* cstr = ToCString();
   intptr_t len = strlen(cstr);
-  // Resulting string is ASCII ...
+// Resulting string is ASCII ...
 #ifdef DEBUG
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(static_cast<uint8_t>(cstr[i]) < 128);
   }
 #endif  // DEBUG
   // ... which is a subset of Latin-1.
   return String::FromLatin1(reinterpret_cast<const uint8_t*>(cstr), len, space);
 }
 
 
@@ skipping 113 matching lines @@
 }
 
 
 RawBigint* Bigint::New(Heap::Space space) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(zone);
   {
-    RawObject* raw = Object::Allocate(Bigint::kClassId,
-                                      Bigint::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Bigint::kClassId, Bigint::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.SetNeg(false);
   result.SetUsed(0);
   result.set_digits(
       TypedData::Handle(zone, TypedData::EmptyUint32Array(thread)));
   return result.raw();
 }
 
 
-RawBigint* Bigint::New(bool neg, intptr_t used, const TypedData& digits,
+RawBigint* Bigint::New(bool neg,
+                       intptr_t used,
+                       const TypedData& digits,
                        Heap::Space space) {
   ASSERT((used == 0) ||
          (!digits.IsNull() && (digits.Length() >= (used + (used & 1)))));
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle(zone);
   {
-    RawObject* raw = Object::Allocate(Bigint::kClassId,
-                                      Bigint::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Bigint::kClassId, Bigint::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   // Clamp the digits array.
   while ((used > 0) && (digits.GetUint32((used - 1) << 2) == 0)) {
     --used;
   }
   if (used > 0) {
     if (((used & 1) != 0) && (digits.GetUint32(used << 2) != 0)) {
       // Set leading zero for 64-bit processing of digit pairs if not set.
@@ skipping 31 matching lines @@
 
 
 RawBigint* Bigint::NewFromUint64(uint64_t value, Heap::Space space) {
   const TypedData& digits = TypedData::Handle(NewDigits(2, space));
   SetDigitAt(digits, 0, static_cast<uint32_t>(value));
   SetDigitAt(digits, 1, static_cast<uint32_t>(value >> 32));
   return New(false, 2, digits, space);
 }
 
 
-RawBigint* Bigint::NewFromShiftedInt64(int64_t value, intptr_t shift,
+RawBigint* Bigint::NewFromShiftedInt64(int64_t value,
+                                       intptr_t shift,
                                        Heap::Space space) {
   ASSERT(kBitsPerDigit == 32);
   ASSERT(shift >= 0);
   const intptr_t digit_shift = shift / kBitsPerDigit;
   const intptr_t bit_shift = shift % kBitsPerDigit;
   const intptr_t used = 3 + digit_shift;
   const TypedData& digits = TypedData::Handle(NewDigits(used, space));
   bool neg;
   uint64_t abs_value;
   if (value < 0) {
     neg = true;
     abs_value = -value;
   } else {
     neg = false;
     abs_value = value;
   }
   for (intptr_t i = 0; i < digit_shift; i++) {
     SetDigitAt(digits, i, 0);
   }
   SetDigitAt(digits, 0 + digit_shift,
              static_cast<uint32_t>(abs_value << bit_shift));
   SetDigitAt(digits, 1 + digit_shift,
              static_cast<uint32_t>(abs_value >> (32 - bit_shift)));
   SetDigitAt(digits, 2 + digit_shift,
-      (bit_shift == 0) ? 0
-                       : static_cast<uint32_t>(abs_value >> (64 - bit_shift)));
+             (bit_shift == 0) ? 0 : static_cast<uint32_t>(abs_value >>
+                                                          (64 - bit_shift)));
   return New(neg, used, digits, space);
 }
 
 
 RawBigint* Bigint::NewFromCString(const char* str, Heap::Space space) {
   ASSERT(str != NULL);
   bool neg = false;
   TypedData& digits = TypedData::Handle();
   if (str[0] == '-') {
     ASSERT(str[1] != '-');
     neg = true;
     str++;
   }
   intptr_t used;
   const intptr_t str_length = strlen(str);
-  if ((str_length >= 2) &&
-      (str[0] == '0') &&
+  if ((str_length >= 2) && (str[0] == '0') &&
       ((str[1] == 'x') || (str[1] == 'X'))) {
     digits = NewDigitsFromHexCString(&str[2], &used, space);
   } else {
     digits = NewDigitsFromDecCString(str, &used, space);
   }
   return New(neg, used, digits, space);
 }
 
 
 RawBigint* Bigint::NewCanonical(const String& str) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
-  const Bigint& value = Bigint::Handle(
-      zone, Bigint::NewFromCString(str.ToCString(), Heap::kOld));
+  const Bigint& value =
+      Bigint::Handle(zone, Bigint::NewFromCString(str.ToCString(), Heap::kOld));
   const Class& cls =
       Class::Handle(zone, isolate->object_store()->bigint_class());
   intptr_t index = 0;
   Bigint& canonical_value = Bigint::Handle(zone);
   canonical_value ^= cls.LookupCanonicalBigint(zone, value, &index);
   if (!canonical_value.IsNull()) {
     return canonical_value.raw();
   }
   {
     SafepointMutexLocker ml(isolate->constant_canonicalization_mutex());
     // Retry lookup.
     {
       canonical_value ^= cls.LookupCanonicalBigint(zone, value, &index);
       if (!canonical_value.IsNull()) {
         return canonical_value.raw();
       }
     }
     value.SetCanonical();
     // The value needs to be added to the constants list. Grow the list if
     // it is full.
     cls.InsertCanonicalNumber(zone, index, value);
     return value.raw();
   }
 }
 
 
-RawTypedData* Bigint::NewDigitsFromHexCString(const char* str, intptr_t* used,
+RawTypedData* Bigint::NewDigitsFromHexCString(const char* str,
+                                              intptr_t* used,
                                               Heap::Space space) {
   const int kBitsPerHexDigit = 4;
   const int kHexDigitsPerDigit = 8;
   const int kBitsPerDigit = kBitsPerHexDigit * kHexDigitsPerDigit;
   intptr_t hex_i = strlen(str);  // Terminating byte excluded.
   if ((hex_i <= 0) || (hex_i >= kMaxInt32)) {
     FATAL("Fatal error parsing hex bigint: string too long or empty");
   }
   const intptr_t length = (hex_i + kHexDigitsPerDigit - 1) / kHexDigitsPerDigit;
   const TypedData& digits = TypedData::Handle(NewDigits(length, space));
@@ skipping 10 matching lines @@
     }
   }
   if (bit_i != 0) {
     SetDigitAt(digits, used_++, digit);
   }
   *used = used_;
   return digits.raw();
 }
 
 
-RawTypedData* Bigint::NewDigitsFromDecCString(const char* str, intptr_t* used,
+RawTypedData* Bigint::NewDigitsFromDecCString(const char* str,
+                                              intptr_t* used,
                                               Heap::Space space) {
   // Read 9 digits a time. 10^9 < 2^32.
   const int kDecDigitsPerIteration = 9;
   const uint32_t kTenMultiplier = 1000000000;
   ASSERT(kBitsPerDigit == 32);
   const intptr_t str_length = strlen(str);
   if ((str_length <= 0) || (str_length >= kMaxInt32)) {
     FATAL("Fatal error parsing dec bigint: string too long or empty");
   }
   // One decimal digit takes log2(10) bits, i.e. ~3.32192809489 bits.
   // That is a theoretical limit for large numbers.
   // The extra 5 digits allocated take care of variations.
   const int64_t kLog10Dividend = 33219281;
   const int64_t kLog10Divisor = 10000000;
-  const intptr_t length = (kLog10Dividend * str_length) /
-                          (kLog10Divisor * kBitsPerDigit) + 5;
+  const intptr_t length =
+      (kLog10Dividend * str_length) / (kLog10Divisor * kBitsPerDigit) + 5;
   const TypedData& digits = TypedData::Handle(NewDigits(length, space));
   // Read first digit separately. This avoids a multiplication and addition.
   // The first digit might also not have kDecDigitsPerIteration decimal digits.
   const intptr_t lsdigit_length = str_length % kDecDigitsPerIteration;
   uint32_t digit = 0;
   intptr_t str_pos = 0;
   for (intptr_t i = 0; i < lsdigit_length; i++) {
     char c = str[str_pos++];
     ASSERT(('0' <= c) && (c <= '9'));
     digit = digit * 10 + c - '0';
@@ skipping 51 matching lines @@
   //
   // which results in a different rounding.
   //
   // For consistency between platforms fallback to GCC style converstion
   // on Win64.
   //
   const int64_t y = static_cast<int64_t>(x);
   if (y > 0) {
     return static_cast<double>(y);
   } else {
-    const double half = static_cast<double>(
-        static_cast<int64_t>(x >> 1) | (y & 1));
+    const double half =
+        static_cast<double>(static_cast<int64_t>(x >> 1) | (y & 1));
     return half + half;
   }
 #else
   return static_cast<double>(x);
 #endif
 }
 
 
 double Bigint::AsDoubleValue() const {
   ASSERT(kBitsPerDigit == 32);
@@ skipping 192 matching lines @@
 
 
 // For positive values: Smi < Mint < Bigint.
 int Bigint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi());
   ASSERT(!FitsIntoInt64());
   if (other.IsBigint() && (IsNegative() == other.IsNegative())) {
     const Bigint& other_bgi = Bigint::Cast(other);
     int64_t result = Used() - other_bgi.Used();
     if (result == 0) {
-      for (intptr_t i = Used(); --i >= 0; ) {
+      for (intptr_t i = Used(); --i >= 0;) {
         result = DigitAt(i);
         result -= other_bgi.DigitAt(i);
         if (result != 0) break;
       }
     }
     if (IsNegative()) {
       result = -result;
     }
     return result > 0 ? 1 : result < 0 ? -1 : 0;
   }
@@ skipping 27 matching lines @@
   uint32_t* rest_digits = zone->Alloc<uint32_t>(used);
   for (intptr_t i = 0; i < used; i++) {
     rest_digits[i] = DigitAt(i);
   }
   if (used == 0) {
     chars[pos++] = '0';
   }
   while (used > 0) {
     uint32_t remainder = 0;
     for (intptr_t i = used - 1; i >= 0; i--) {
-      uint64_t dividend = (static_cast<uint64_t>(remainder) << kBitsPerDigit) +
-          rest_digits[i];
+      uint64_t dividend =
+          (static_cast<uint64_t>(remainder) << kBitsPerDigit) + rest_digits[i];
       uint32_t quotient = static_cast<uint32_t>(dividend / kDivisor);
       remainder = static_cast<uint32_t>(
           dividend - static_cast<uint64_t>(quotient) * kDivisor);
       rest_digits[i] = quotient;
     }
     // Clamp rest_digits.
     while ((used > 0) && (rest_digits[used - 1] == 0)) {
       used--;
     }
     for (intptr_t i = 0; i < kDigits; i++) {
@@ skipping 77 matching lines @@
 
 const char* Bigint::ToCString() const {
   return ToDecCString(Thread::Current()->zone());
 }
 
 
 // Synchronize with implementation in compiler (intrinsifier).
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
-  void Add(int32_t ch) {
-    hash_ = CombineHashes(hash_, ch);
-  }
+  void Add(int32_t ch) { hash_ = CombineHashes(hash_, ch); }
   void Add(const String& str, intptr_t begin_index, intptr_t len);
 
   // Return a non-zero hash of at most 'bits' bits.
   intptr_t Finalize(int bits) {
     ASSERT(1 <= bits && bits <= (kBitsPerWord - 1));
     hash_ = FinalizeHash(hash_, bits);
     ASSERT(hash_ <= static_cast<uint32_t>(kMaxInt32));
     return hash_;
   }
+
  private:
   uint32_t hash_;
 };
 
 
 void StringHasher::Add(const String& str, intptr_t begin_index, intptr_t len) {
   ASSERT(begin_index >= 0);
   ASSERT(len >= 0);
   ASSERT((begin_index + len) <= str.Length());
   if (len == 0) {
@@ skipping 31 matching lines @@
     return temp.Hash();
   } else {
     StringHasher hasher;
     hasher.Add(str1, 0, len1);
     hasher.Add(str2, 0, str2.Length());
     return hasher.Finalize(kHashBits);
   }
 }
 
 
-template<typename T>
+template <typename T>
 static intptr_t HashImpl(const T* characters, intptr_t len) {
   ASSERT(len >= 0);
   StringHasher hasher;
   for (intptr_t i = 0; i < len; i++) {
     hasher.Add(characters[i]);
   }
   return hasher.Finalize(String::kHashBits);
 }
 
 
@@ skipping 99 matching lines @@
   ASSERT((begin_index == 0) || (begin_index < str.Length()));
   ASSERT(len >= 0);
   ASSERT(len <= str.Length());
   if (len != this->Length()) {
     return false;  // Lengths don't match.
   }
 
   Scanner::CharAtFunc this_char_at_func = this->CharAtFunc();
   Scanner::CharAtFunc str_char_at_func = str.CharAtFunc();
   for (intptr_t i = 0; i < len; i++) {
-    if (this_char_at_func(*this, i) !=
-        str_char_at_func(str, begin_index + i)) {
+    if (this_char_at_func(*this, i) != str_char_at_func(str, begin_index + i)) {
       return false;
     }
   }
 
   return true;
 }
 
 
 bool String::Equals(const char* cstr) const {
   ASSERT(cstr != NULL);
   CodePointIterator it(*this);
   intptr_t len = strlen(cstr);
   while (it.Next()) {
     if (*cstr == '\0') {
       // Lengths don't match.
       return false;
     }
     int32_t ch;
-    intptr_t consumed = Utf8::Decode(reinterpret_cast<const uint8_t*>(cstr),
-                                     len,
-                                     &ch);
+    intptr_t consumed =
+        Utf8::Decode(reinterpret_cast<const uint8_t*>(cstr), len, &ch);
     if (consumed == 0 || it.Current() != ch) {
       return false;
     }
     cstr += consumed;
     len -= consumed;
   }
   return *cstr == '\0';
 }
 
 
@@ skipping 41 matching lines @@
       if (j >= Length()) return false;
       if (CharAt(j++) != utf32_array[i]) return false;
     }
   }
   return j == Length();
 }
 
 
 bool String::EqualsConcat(const String& str1, const String& str2) const {
   return (Length() == str1.Length() + str2.Length()) &&
-    str1.Equals(*this, 0, str1.Length()) &&
-    str2.Equals(*this, str1.Length(), str2.Length());
+         str1.Equals(*this, 0, str1.Length()) &&
+         str2.Equals(*this, str1.Length(), str2.Length());
 }
 
 
 intptr_t String::CompareTo(const String& other) const {
   const intptr_t this_len = this->Length();
   const intptr_t other_len = other.IsNull() ? 0 : other.Length();
   const intptr_t len = (this_len < other_len) ? this_len : other_len;
   for (intptr_t i = 0; i < len; i++) {
     uint16_t this_code_unit = this->CharAt(i);
     uint16_t other_code_unit = other.CharAt(i);
@@ skipping 60 matching lines @@
     if (len > 0) {
       NoSafepointScope no_safepoint;
       Utf8::DecodeToLatin1(utf8_array, array_len,
                            OneByteString::CharAddr(strobj, 0), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSupplementary));
   const String& strobj = String::Handle(TwoByteString::New(len, space));
   NoSafepointScope no_safepoint;
-  Utf8::DecodeToUTF16(utf8_array, array_len,
-                      TwoByteString::CharAddr(strobj, 0), len);
+  Utf8::DecodeToUTF16(utf8_array, array_len, TwoByteString::CharAddr(strobj, 0),
+                      len);
   return strobj.raw();
 }
 
 
 RawString* String::FromLatin1(const uint8_t* latin1_array,
                               intptr_t array_len,
                               Heap::Space space) {
   return OneByteString::New(latin1_array, array_len, space);
 }
 
@@ skipping 65 matching lines @@
 
 RawString* String::NewExternal(const uint16_t* characters,
                                intptr_t len,
                                void* peer,
                                Dart_PeerFinalizer callback,
                                Heap::Space space) {
   return ExternalTwoByteString::New(characters, len, peer, callback, space);
 }
 
 
-void String::Copy(const String& dst, intptr_t dst_offset,
+void String::Copy(const String& dst,
+                  intptr_t dst_offset,
                   const uint8_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
     NoSafepointScope no_safepoint;
     if (len > 0) {
-      memmove(OneByteString::CharAddr(dst, dst_offset),
-              characters,
-              len);
+      memmove(OneByteString::CharAddr(dst, dst_offset), characters, len);
     }
   } else if (dst.IsTwoByteString()) {
     for (intptr_t i = 0; i < len; ++i) {
       *TwoByteString::CharAddr(dst, i + dst_offset) = characters[i];
     }
   }
 }
 
 
-void String::Copy(const String& dst, intptr_t dst_offset,
+void String::Copy(const String& dst,
+                  intptr_t dst_offset,
                   const uint16_t* utf16_array,
                   intptr_t array_len) {
   ASSERT(dst_offset >= 0);
   ASSERT(array_len >= 0);
   ASSERT(array_len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
     NoSafepointScope no_safepoint;
     for (intptr_t i = 0; i < array_len; ++i) {
       ASSERT(Utf::IsLatin1(utf16_array[i]));
       *OneByteString::CharAddr(dst, i + dst_offset) = utf16_array[i];
     }
   } else {
     ASSERT(dst.IsTwoByteString());
     NoSafepointScope no_safepoint;
     if (array_len > 0) {
-      memmove(TwoByteString::CharAddr(dst, dst_offset),
-              utf16_array,
+      memmove(TwoByteString::CharAddr(dst, dst_offset), utf16_array,
               array_len * 2);
     }
   }
 }
 
 
-void String::Copy(const String& dst, intptr_t dst_offset,
-                  const String& src, intptr_t src_offset,
+void String::Copy(const String& dst,
+                  intptr_t dst_offset,
+                  const String& src,
+                  intptr_t src_offset,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(src_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   ASSERT(len <= (src.Length() - src_offset));
   if (len > 0) {
     intptr_t char_size = src.CharSize();
     if (char_size == kOneByteChar) {
       if (src.IsOneByteString()) {
         NoSafepointScope no_safepoint;
-        String::Copy(dst,
-                     dst_offset,
-                     OneByteString::CharAddr(src, src_offset),
+        String::Copy(dst, dst_offset, OneByteString::CharAddr(src, src_offset),
                      len);
       } else {
         ASSERT(src.IsExternalOneByteString());
         NoSafepointScope no_safepoint;
-        String::Copy(dst,
-                     dst_offset,
-                     ExternalOneByteString::CharAddr(src, src_offset),
-                     len);
+        String::Copy(dst, dst_offset,
+                     ExternalOneByteString::CharAddr(src, src_offset), len);
       }
     } else {
       ASSERT(char_size == kTwoByteChar);
       if (src.IsTwoByteString()) {
         NoSafepointScope no_safepoint;
-        String::Copy(dst,
-                     dst_offset,
-                     TwoByteString::CharAddr(src, src_offset),
+        String::Copy(dst, dst_offset, TwoByteString::CharAddr(src, src_offset),
                      len);
       } else {
         ASSERT(src.IsExternalTwoByteString());
         NoSafepointScope no_safepoint;
-        String::Copy(dst,
-                     dst_offset,
-                     ExternalTwoByteString::CharAddr(src, src_offset),
-                     len);
+        String::Copy(dst, dst_offset,
+                     ExternalTwoByteString::CharAddr(src, src_offset), len);
       }
     }
   }
 }
 
 
 RawString* String::EscapeSpecialCharacters(const String& str) {
   if (str.IsOneByteString()) {
     return OneByteString::EscapeSpecialCharacters(str);
   }
@@ skipping 168 matching lines @@
 RawString* String::NewFormatted(Heap::Space space, const char* format, ...) {
   va_list args;
   va_start(args, format);
   RawString* result = NewFormattedV(format, args, space);
   NoSafepointScope no_safepoint;
   va_end(args);
   return result;
 }
 
 
-RawString* String::NewFormattedV(const char* format, va_list args,
+RawString* String::NewFormattedV(const char* format,
+                                 va_list args,
                                  Heap::Space space) {
   va_list args_copy;
   va_copy(args_copy, args);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args_copy);
   va_end(args_copy);
 
   Zone* zone = Thread::Current()->zone();
   char* buffer = zone->Alloc<char>(len + 1);
   OS::VSNPrint(buffer, (len + 1), format, args);
 
   return String::New(buffer, space);
 }
 
 
 RawString* String::Concat(const String& str1,
                           const String& str2,
                           Heap::Space space) {
   ASSERT(!str1.IsNull() && !str2.IsNull());
   intptr_t char_size = Utils::Maximum(str1.CharSize(), str2.CharSize());
   if (char_size == kTwoByteChar) {
     return TwoByteString::Concat(str1, str2, space);
   }
   return OneByteString::Concat(str1, str2, space);
 }
 
 
-RawString* String::ConcatAll(const Array& strings,
-                             Heap::Space space) {
+RawString* String::ConcatAll(const Array& strings, Heap::Space space) {
   return ConcatAllRange(strings, 0, strings.Length(), space);
 }
 
 
 RawString* String::ConcatAllRange(const Array& strings,
                                   intptr_t start,
                                   intptr_t end,
                                   Heap::Space space) {
   ASSERT(!strings.IsNull());
   ASSERT(start >= 0);
@@ skipping 20 matching lines @@
 }
 
 
 RawString* String::SubString(const String& str,
                              intptr_t begin_index,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   if (begin_index >= str.Length()) {
     return String::null();
   }
-  return String::SubString(str,
-                           begin_index,
-                           (str.Length() - begin_index),
+  return String::SubString(str, begin_index, (str.Length() - begin_index),
                            space);
 }
 
 
 RawString* String::SubString(Thread* thread,
                              const String& str,
                              intptr_t begin_index,
                              intptr_t length,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
@@ skipping 66 matching lines @@
 }
 
 
 static FinalizablePersistentHandle* AddFinalizer(
     const Object& referent,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback,
     intptr_t external_size) {
   ASSERT((callback != NULL && peer != NULL) ||
          (callback == NULL && peer == NULL));
-  return FinalizablePersistentHandle::New(Isolate::Current(),
-                                          referent,
-                                          peer,
-                                          callback,
-                                          external_size);
+  return FinalizablePersistentHandle::New(Isolate::Current(), referent, peer,
+                                          callback, external_size);
 }
 
 
 RawString* String::MakeExternal(void* array,
                                 intptr_t external_size,
                                 void* peer,
                                 Dart_PeerFinalizer cback) const {
   ASSERT(FLAG_support_externalizable_strings);
   String& result = String::Handle();
   void* external_data;
@@ skipping 26 matching lines @@
       uword tags = raw_ptr()->tags_;
       uword old_tags;
       do {
         old_tags = tags;
         uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
         new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
         tags = CompareAndSwapTags(old_tags, new_tags);
       } while (tags != old_tags);
       result = this->raw();
       const uint8_t* ext_array = reinterpret_cast<const uint8_t*>(array);
-      ExternalStringData<uint8_t>* ext_data = new ExternalStringData<uint8_t>(
-          ext_array, peer, cback);
+      ExternalStringData<uint8_t>* ext_data =
+          new ExternalStringData<uint8_t>(ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalOneByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
       finalizer = ExternalOneByteString::Finalize;
     } else {
       ASSERT(class_id == kTwoByteStringCid);
       intptr_t used_size = ExternalTwoByteString::InstanceSize();
       intptr_t original_size = TwoByteString::InstanceSize(str_length);
       ASSERT(original_size >= used_size);
 
       // Copy the data into the external array.
       if (str_length > 0) {
-        memmove(array,
-                TwoByteString::CharAddr(*this, 0),
+        memmove(array, TwoByteString::CharAddr(*this, 0),
                 (str_length * kTwoByteChar));
       }
 
       // If there is any left over space fill it with either an Array object or
       // just a plain object (depending on the amount of left over space) so
       // that it can be traversed over successfully during garbage collection.
       Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
 
       // Update the class information of the object.
       const intptr_t class_id = kExternalTwoByteStringCid;
       uword tags = raw_ptr()->tags_;
       uword old_tags;
       do {
         old_tags = tags;
         uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
         new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
         tags = CompareAndSwapTags(old_tags, new_tags);
       } while (tags != old_tags);
       result = this->raw();
       const uint16_t* ext_array = reinterpret_cast<const uint16_t*>(array);
-      ExternalStringData<uint16_t>* ext_data = new ExternalStringData<uint16_t>(
-          ext_array, peer, cback);
+      ExternalStringData<uint16_t>* ext_data =
+          new ExternalStringData<uint16_t>(ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalTwoByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
       finalizer = ExternalTwoByteString::Finalize;
     }
   }  // NoSafepointScope
   AddFinalizer(result, external_data, finalizer, external_size);
   return this->raw();
@@ skipping 31 matching lines @@
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 bool String::ParseDouble(const String& str,
-                         intptr_t start, intptr_t end,
+                         intptr_t start,
+                         intptr_t end,
                          double* result) {
   ASSERT(0 <= start);
   ASSERT(start <= end);
   ASSERT(end <= str.Length());
   intptr_t length = end - start;
   NoSafepointScope no_safepoint;
   const uint8_t* startChar;
   if (str.IsOneByteString()) {
     startChar = OneByteString::CharAddr(str, start);
   } else if (str.IsExternalOneByteString()) {
     startChar = ExternalOneByteString::CharAddr(str, start);
   } else {
     uint8_t* chars = Thread::Current()->zone()->Alloc<uint8_t>(length);
     const Scanner::CharAtFunc char_at = str.CharAtFunc();
     for (intptr_t i = 0; i < length; i++) {
       int32_t ch = char_at(str, start + i);
       if (ch < 128) {
         chars[i] = ch;
       } else {
         return false;  // Not ASCII, so definitely not valid double numeral.
       }
     }
     startChar = chars;
   }
-  return CStringToDouble(reinterpret_cast<const char*>(startChar),
-                         length, result);
+  return CStringToDouble(reinterpret_cast<const char*>(startChar), length,
+                         result);
 }
 
 
 // Check to see if 'str1' matches 'str2' as is or
 // once the private key separator is stripped from str2.
 //
 // Things are made more complicated by the fact that constructors are
 // added *after* the private suffix, so "foo@123.named" should match
 // "foo.named".
 //
 // Also, the private suffix can occur more than once in the name, as in:
 //
 //    _ReceivePortImpl@6be832b._internal@6be832b
 //
-template<typename T1, typename T2>
-static bool EqualsIgnoringPrivateKey(const String& str1,
-                                     const String& str2) {
+template <typename T1, typename T2>
+static bool EqualsIgnoringPrivateKey(const String& str1, const String& str2) {
   intptr_t len = str1.Length();
   intptr_t str2_len = str2.Length();
   if (len == str2_len) {
     for (intptr_t i = 0; i < len; i++) {
       if (T1::CharAt(str1, i) != T2::CharAt(str2, i)) {
         return false;
       }
     }
     return true;
   }
@@ skipping 21 matching lines @@
   }
 
   // We have reached the end of mangled_name string.
   ASSERT(pos == len);
   return (str2_pos == str2_len);
 }
 
 
 #define EQUALS_IGNORING_PRIVATE_KEY(class_id, type, str1, str2)                \
   switch (class_id) {                                                          \
-    case kOneByteStringCid :                                                   \
+    case kOneByteStringCid:                                                    \
       return dart::EqualsIgnoringPrivateKey<type, OneByteString>(str1, str2);  \
-    case kTwoByteStringCid :                                                   \
+    case kTwoByteStringCid:                                                    \
       return dart::EqualsIgnoringPrivateKey<type, TwoByteString>(str1, str2);  \
-    case kExternalOneByteStringCid :                                           \
-      return dart::EqualsIgnoringPrivateKey<type, ExternalOneByteString>(str1, \
-                                                                         str2);\
-    case kExternalTwoByteStringCid :                                           \
-      return dart::EqualsIgnoringPrivateKey<type, ExternalTwoByteString>(str1, \
-                                                                         str2);\
+    case kExternalOneByteStringCid:                                            \
+      return dart::EqualsIgnoringPrivateKey<type, ExternalOneByteString>(      \
+          str1, str2);                                                         \
+    case kExternalTwoByteStringCid:                                            \
+      return dart::EqualsIgnoringPrivateKey<type, ExternalTwoByteString>(      \
+          str1, str2);                                                         \
   }                                                                            \
-  UNREACHABLE();                                                               \
+  UNREACHABLE();
 
 
-bool String::EqualsIgnoringPrivateKey(const String& str1,
-                                      const String& str2) {
+bool String::EqualsIgnoringPrivateKey(const String& str1, const String& str2) {
   if (str1.raw() == str2.raw()) {
     return true;  // Both handles point to the same raw instance.
   }
   NoSafepointScope no_safepoint;
   intptr_t str1_class_id = str1.raw()->GetClassId();
   intptr_t str2_class_id = str2.raw()->GetClassId();
   switch (str1_class_id) {
-    case kOneByteStringCid :
+    case kOneByteStringCid:
       EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, OneByteString, str1, str2);
       break;
-    case kTwoByteStringCid :
+    case kTwoByteStringCid:
       EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, TwoByteString, str1, str2);
       break;
-    case kExternalOneByteStringCid :
-      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id,
-                                  ExternalOneByteString, str1, str2);
+    case kExternalOneByteStringCid:
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, ExternalOneByteString, str1,
+                                  str2);
       break;
-    case kExternalTwoByteStringCid :
-      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id,
-                                  ExternalTwoByteString, str1, str2);
+    case kExternalTwoByteStringCid:
+      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, ExternalTwoByteString, str1,
+                                  str2);
       break;
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool String::CodePointIterator::Next() {
   ASSERT(index_ >= -1);
   intptr_t length = Utf16::Length(ch_);
@@ skipping 13 matching lines @@
 }
 
 
 RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
       num_escapes += EscapeOverhead(CharAt(str, i));
     }
-    const String& dststr = String::Handle(
-        OneByteString::New(len + num_escapes, Heap::kNew));
+    const String& dststr =
+        String::Handle(OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint8_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
       } else if (IsAsciiNonprintable(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, 'x');
@@ skipping 12 matching lines @@
 
 
 RawOneByteString* ExternalOneByteString::EscapeSpecialCharacters(
     const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
       num_escapes += EscapeOverhead(CharAt(str, i));
     }
-    const String& dststr = String::Handle(
-        OneByteString::New(len + num_escapes, Heap::kNew));
+    const String& dststr =
+        String::Handle(OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint8_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         OneByteString::SetCharAt(dststr, index, '\\');
         OneByteString::SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
       } else if (IsAsciiNonprintable(ch)) {
         OneByteString::SetCharAt(dststr, index, '\\');
         OneByteString::SetCharAt(dststr, index + 1, 'x');
         OneByteString::SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
         OneByteString::SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
         index += 4;
       } else {
         OneByteString::SetCharAt(dststr, index, ch);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::raw(Symbols::Empty());
 }
 
 
-RawOneByteString* OneByteString::New(intptr_t len,
-                                     Heap::Space space) {
+RawOneByteString* OneByteString::New(intptr_t len, Heap::Space space) {
   ASSERT((Isolate::Current() == Dart::vm_isolate()) ||
          ((Isolate::Current()->object_store() != NULL) &&
           (Isolate::Current()->object_store()->one_byte_string_class() !=
            Class::null())));
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %" Pd "\n", len);
   }
   {
     RawObject* raw = Object::Allocate(OneByteString::kClassId,
-                                      OneByteString::InstanceSize(len),
-                                      space);
+                                      OneByteString::InstanceSize(len), space);
     NoSafepointScope no_safepoint;
     RawOneByteString* result = reinterpret_cast<RawOneByteString*>(raw);
     result->StoreSmi(&(result->ptr()->length_), Smi::New(len));
     result->StoreSmi(&(result->ptr()->hash_), Smi::New(0));
     return result;
   }
 }
 
 
 RawOneByteString* OneByteString::New(const uint8_t* characters,
@@ skipping 27 matching lines @@
   const String& result = String::Handle(OneByteString::New(len, space));
   NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
-RawOneByteString* OneByteString::New(const String& str,
-                                     Heap::Space space) {
+RawOneByteString* OneByteString::New(const String& str, Heap::Space space) {
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, str, 0, len);
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const String& other_one_byte_string,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
@@ skipping 12 matching lines @@
 
 RawOneByteString* OneByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
     memmove(OneByteString::CharAddr(result, 0),
-            other_typed_data.DataAddr(other_start_index),
-            other_len);
+            other_typed_data.DataAddr(other_start_index), other_len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const ExternalTypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(other_len, space));
   ASSERT(other_typed_data.ElementSizeInBytes() == 1);
   if (other_len > 0) {
     NoSafepointScope no_safepoint;
     memmove(OneByteString::CharAddr(result, 0),
-            other_typed_data.DataAddr(other_start_index),
-            other_len);
+            other_typed_data.DataAddr(other_start_index), other_len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Concat(const String& str1,
                                         const String& str2,
                                         Heap::Space space) {
   intptr_t len1 = str1.Length();
   intptr_t len2 = str2.Length();
@@ skipping 51 matching lines @@
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index <= str.Length() && length == 0) {
     return OneByteString::raw(Symbols::Empty());
   }
   ASSERT(begin_index < str.Length());
   RawOneByteString* result = OneByteString::New(length, space);
   NoSafepointScope no_safepoint;
   if (length > 0) {
     uint8_t* dest = &result->ptr()->data()[0];
-    const uint8_t* src =  &raw_ptr(str)->data()[begin_index];
+    const uint8_t* src = &raw_ptr(str)->data()[begin_index];
     memmove(dest, src, length);
   }
   return result;
 }
 
 
 void OneByteString::SetPeer(const String& str,
                             intptr_t external_size,
                             void* peer,
                             Dart_PeerFinalizer cback) {
@@ skipping 13 matching lines @@
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
       num_escapes += EscapeOverhead(CharAt(str, i));
     }
-    const String& dststr = String::Handle(
-        TwoByteString::New(len + num_escapes, Heap::kNew));
+    const String& dststr =
+        String::Handle(TwoByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint16_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
       } else if (IsAsciiNonprintable(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, 'x');
         SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
         SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
         index += 4;
       } else {
         SetCharAt(dststr, index, ch);
         index += 1;
       }
     }
     return TwoByteString::raw(dststr);
   }
   return TwoByteString::New(0, Heap::kNew);
 }
 
 
-RawTwoByteString* TwoByteString::New(intptr_t len,
-                                     Heap::Space space) {
+RawTwoByteString* TwoByteString::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->two_byte_string_class());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TwoByteString::New: invalid len %" Pd "\n", len);
   }
   String& result = String::Handle();
   {
     RawObject* raw = Object::Allocate(TwoByteString::kClassId,
-                                      TwoByteString::InstanceSize(len),
-                                      space);
+                                      TwoByteString::InstanceSize(len), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(const uint16_t* utf16_array,
@@ skipping 27 matching lines @@
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
       }
     }
   }
   return TwoByteString::raw(result);
 }
 
 
-RawTwoByteString* TwoByteString::New(const String& str,
-                                     Heap::Space space) {
+RawTwoByteString* TwoByteString::New(const String& str, Heap::Space space) {
   intptr_t len = str.Length();
   const String& result = String::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, str, 0, len);
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(const TypedData& other_typed_data,
                                      intptr_t other_start_index,
                                      intptr_t other_len,
@@ skipping 104 matching lines @@
   delete reinterpret_cast<ExternalStringData<uint16_t>*>(peer);
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::New(
     const uint8_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
     Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->
-         external_one_byte_string_class() != Class::null());
+  ASSERT(Isolate::Current()->object_store()->external_one_byte_string_class() !=
+         Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExternalOneByteString::New: invalid len %" Pd "\n",
            len);
   }
   String& result = String::Handle();
   ExternalStringData<uint8_t>* external_data =
       new ExternalStringData<uint8_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(ExternalOneByteString::kClassId,
-                                      ExternalOneByteString::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(ExternalOneByteString::kClassId,
+                         ExternalOneByteString::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     SetExternalData(result, external_data);
   }
   intptr_t external_size = len;
   AddFinalizer(result, external_data, ExternalOneByteString::Finalize,
                external_size);
   return ExternalOneByteString::raw(result);
@@ skipping 17 matching lines @@
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExternalTwoByteString::New: invalid len %" Pd "\n",
            len);
   }
   String& result = String::Handle();
   ExternalStringData<uint16_t>* external_data =
       new ExternalStringData<uint16_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(ExternalTwoByteString::kClassId,
-                                      ExternalTwoByteString::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(ExternalTwoByteString::kClassId,
+                         ExternalTwoByteString::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     SetExternalData(result, external_data);
   }
   intptr_t external_size = len * 2;
   AddFinalizer(result, external_data, ExternalTwoByteString::Finalize,
                external_size);
   return ExternalTwoByteString::raw(result);
 }
 
 
 void ExternalTwoByteString::Finalize(void* isolate_callback_data,
                                      Dart_WeakPersistentHandle handle,
                                      void* peer) {
   delete reinterpret_cast<ExternalStringData<uint16_t>*>(peer);
 }
 
 
 RawBool* Bool::New(bool value) {
   ASSERT(Isolate::Current()->object_store()->bool_class() != Class::null());
   Bool& result = Bool::Handle();
   {
     // Since the two boolean instances are singletons we allocate them straight
     // in the old generation.
-    RawObject* raw = Object::Allocate(Bool::kClassId,
-                                      Bool::InstanceSize(),
-                                      Heap::kOld);
+    RawObject* raw =
+        Object::Allocate(Bool::kClassId, Bool::InstanceSize(), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
@@ skipping 24 matching lines @@
     if (this->At(i) != other_arr.At(i)) {
       return false;
     }
   }
 
   // Now check if both arrays have the same type arguments.
   if (GetTypeArguments() == other.GetTypeArguments()) {
     return true;
   }
   const TypeArguments& type_args = TypeArguments::Handle(GetTypeArguments());
-  const TypeArguments& other_type_args = TypeArguments::Handle(
-      other.GetTypeArguments());
+  const TypeArguments& other_type_args =
+      TypeArguments::Handle(other.GetTypeArguments());
   if (!type_args.Equals(other_type_args)) {
     return false;
   }
   return true;
 }
 
 
 uword Array::ComputeCanonicalTableHash() const {
   ASSERT(!IsNull());
   NoSafepointScope no_safepoint;
@@ skipping 15 matching lines @@
 }
 
 
 RawArray* Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > Array::kMaxElements)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
   }
   {
     RawArray* raw = reinterpret_cast<RawArray*>(
-        Object::Allocate(class_id,
-                         Array::InstanceSize(len),
-                         space));
+        Object::Allocate(class_id, Array::InstanceSize(len), space));
     NoSafepointScope no_safepoint;
     raw->StoreSmi(&(raw->ptr()->length_), Smi::New(len));
     return raw;
   }
 }
 
 
 RawArray* Array::Slice(intptr_t start,
                        intptr_t count,
                        bool with_type_argument) const {
@@ skipping 12 matching lines @@
 
 
 void Array::MakeImmutable() const {
   if (IsImmutable()) return;
   ASSERT(!IsCanonical());
   NoSafepointScope no_safepoint;
   uword tags = raw_ptr()->tags_;
   uword old_tags;
   do {
     old_tags = tags;
-    uword new_tags = RawObject::ClassIdTag::update(kImmutableArrayCid,
-                                                   old_tags);
+    uword new_tags =
+        RawObject::ClassIdTag::update(kImmutableArrayCid, old_tags);
     tags = CompareAndSwapTags(old_tags, new_tags);
   } while (tags != old_tags);
 }
 
 
 const char* Array::ToCString() const {
   if (IsNull()) {
     return IsImmutable() ? "_ImmutableList NULL" : "_List NULL";
   }
   Zone* zone = Thread::Current()->zone();
-  const char* format = IsImmutable() ? "_ImmutableList len:%" Pd
-                                     : "_List len:%" Pd;
+  const char* format =
+      IsImmutable() ? "_ImmutableList len:%" Pd : "_List len:%" Pd;
   return zone->PrintToString(format, Length());
 }
 
 
 RawArray* Array::Grow(const Array& source,
                       intptr_t new_length,
                       Heap::Space space) {
   Zone* zone = Thread::Current()->zone();
   const Array& result = Array::Handle(zone, Array::New(new_length, space));
   intptr_t len = 0;
@@ skipping 75 matching lines @@
     // other instances to be canonical otherwise report error (return false).
     for (intptr_t i = 0; i < len; i++) {
       obj = At(i);
       if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
         if (obj.IsNumber() || obj.IsString()) {
           obj = Instance::Cast(obj).CheckAndCanonicalize(thread, NULL);
           ASSERT(!obj.IsNull());
           this->SetAt(i, obj);
         } else {
           ASSERT(error_str != NULL);
-          char* chars = OS::SCreate(
-              zone, "element at index %" Pd ": %s\n", i, obj.ToCString());
+          char* chars = OS::SCreate(zone, "element at index %" Pd ": %s\n", i,
+                                    obj.ToCString());
           *error_str = chars;
           return false;
         }
       }
     }
   }
   return true;
 }
 
 
-RawImmutableArray* ImmutableArray::New(intptr_t len,
-                                       Heap::Space space) {
+RawImmutableArray* ImmutableArray::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->immutable_array_class() !=
          Class::null());
   return reinterpret_cast<RawImmutableArray*>(Array::New(kClassId, len, space));
 }
 
 
 void GrowableObjectArray::Add(const Object& value, Heap::Space space) const {
   ASSERT(!IsNull());
   if (Length() == Capacity()) {
     // TODO(Issue 2500): Need a better growth strategy.
@@ skipping 34 matching lines @@
 
 RawGrowableObjectArray* GrowableObjectArray::New(intptr_t capacity,
                                                  Heap::Space space) {
   const Array& data = Array::Handle(Array::New(capacity, space));
   return New(data, space);
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::New(const Array& array,
                                                  Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->growable_object_array_class()
-         != Class::null());
+  ASSERT(Isolate::Current()->object_store()->growable_object_array_class() !=
+         Class::null());
   GrowableObjectArray& result = GrowableObjectArray::Handle();
   {
-    RawObject* raw = Object::Allocate(GrowableObjectArray::kClassId,
-                                      GrowableObjectArray::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(GrowableObjectArray::kClassId,
+                         GrowableObjectArray::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(0);
     result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
     return "_GrowableList NULL";
   }
   return OS::SCreate(Thread::Current()->zone(),
-      "Instance(length:%" Pd ") of '_GrowableList'", Length());
+                     "Instance(length:%" Pd ") of '_GrowableList'", Length());
 }
 
 
 // Equivalent to Dart's operator "==" and hashCode.
 class DefaultHashTraits {
  public:
   static const char* Name() { return "DefaultHashTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const Object& a, const Object& b) {
@@ skipping 21 matching lines @@
           Integer::Cast(hash_code).AsTruncatedUint32Value());
     } else {
       return 0;
     }
   }
 };
 
 
 RawLinkedHashMap* LinkedHashMap::NewDefault(Heap::Space space) {
   const Array& data = Array::Handle(Array::New(kInitialIndexSize, space));
-  const TypedData& index = TypedData::Handle(TypedData::New(
-      kTypedDataUint32ArrayCid, kInitialIndexSize, space));
+  const TypedData& index = TypedData::Handle(
+      TypedData::New(kTypedDataUint32ArrayCid, kInitialIndexSize, space));
   // On 32-bit, the top bits are wasted to avoid Mint allocation.
   static const intptr_t kAvailableBits = (kSmiBits >= 32) ? 32 : kSmiBits;
   static const intptr_t kInitialHashMask =
       (1 << (kAvailableBits - kInitialIndexBits)) - 1;
   return LinkedHashMap::New(data, index, kInitialHashMask, 0, 0, space);
 }
 
 
 RawLinkedHashMap* LinkedHashMap::New(const Array& data,
                                      const TypedData& index,
                                      intptr_t hash_mask,
                                      intptr_t used_data,
                                      intptr_t deleted_keys,
                                      Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->linked_hash_map_class()
-         != Class::null());
-  LinkedHashMap& result = LinkedHashMap::Handle(
-      LinkedHashMap::NewUninitialized(space));
+  ASSERT(Isolate::Current()->object_store()->linked_hash_map_class() !=
+         Class::null());
+  LinkedHashMap& result =
+      LinkedHashMap::Handle(LinkedHashMap::NewUninitialized(space));
   result.SetData(data);
   result.SetIndex(index);
   result.SetHashMask(hash_mask);
   result.SetUsedData(used_data);
   result.SetDeletedKeys(deleted_keys);
   return result.raw();
 }
 
 
 RawLinkedHashMap* LinkedHashMap::NewUninitialized(Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->linked_hash_map_class()
-         != Class::null());
+  ASSERT(Isolate::Current()->object_store()->linked_hash_map_class() !=
+         Class::null());
   LinkedHashMap& result = LinkedHashMap::Handle();
   {
     RawObject* raw = Object::Allocate(LinkedHashMap::kClassId,
-                                      LinkedHashMap::InstanceSize(),
-                                      space);
+                                      LinkedHashMap::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   return result.raw();
 }
 
 
 const char* LinkedHashMap::ToCString() const {
   Zone* zone = Thread::Current()->zone();
   return zone->PrintToString("_LinkedHashMap len:%" Pd, Length());
 }
 
 
-RawFloat32x4* Float32x4::New(float v0, float v1, float v2, float v3,
+RawFloat32x4* Float32x4::New(float v0,
+                             float v1,
+                             float v2,
+                             float v3,
                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Float32x4::kClassId,
-                                      Float32x4::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Float32x4::kClassId, Float32x4::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
 RawFloat32x4* Float32x4::New(simd128_value_t value, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
          Class::null());
   Float32x4& result = Float32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Float32x4::kClassId,
-                                      Float32x4::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Float32x4::kClassId, Float32x4::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 simd128_value_t Float32x4::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
@@ skipping 43 matching lines @@
 float Float32x4::w() const {
   return raw_ptr()->value_[3];
 }
 
 
 const char* Float32x4::ToCString() const {
   float _x = x();
   float _y = y();
   float _z = z();
   float _w = w();
-  return OS::SCreate(Thread::Current()->zone(),
-      "[%f, %f, %f, %f]", _x, _y, _z, _w);
+  return OS::SCreate(Thread::Current()->zone(), "[%f, %f, %f, %f]", _x, _y, _z,
+                     _w);
 }
 
 
-RawInt32x4* Int32x4::New(int32_t v0, int32_t v1, int32_t v2, int32_t v3,
+RawInt32x4* Int32x4::New(int32_t v0,
+                         int32_t v1,
+                         int32_t v2,
+                         int32_t v3,
                          Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
-         Class::null());
+  ASSERT(Isolate::Current()->object_store()->int32x4_class() != Class::null());
   Int32x4& result = Int32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Int32x4::kClassId,
-                                      Int32x4::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Int32x4::kClassId, Int32x4::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
 RawInt32x4* Int32x4::New(simd128_value_t value, Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->int32x4_class() !=
-         Class::null());
+  ASSERT(Isolate::Current()->object_store()->int32x4_class() != Class::null());
   Int32x4& result = Int32x4::Handle();
   {
-    RawObject* raw = Object::Allocate(Int32x4::kClassId,
-                                      Int32x4::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Int32x4::kClassId, Int32x4::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 void Int32x4::set_x(int32_t value) const {
   StoreNonPointer(&raw_ptr()->value_[0], value);
@@ skipping 43 matching lines @@
 void Int32x4::set_value(simd128_value_t value) const {
   StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Int32x4::ToCString() const {
   int32_t _x = x();
   int32_t _y = y();
   int32_t _z = z();
   int32_t _w = w();
-  return OS::SCreate(Thread::Current()->zone(),
-      "[%08x, %08x, %08x, %08x]", _x, _y, _z, _w);
+  return OS::SCreate(Thread::Current()->zone(), "[%08x, %08x, %08x, %08x]", _x,
+                     _y, _z, _w);
 }
 
 
 RawFloat64x2* Float64x2::New(double value0, double value1, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
          Class::null());
   Float64x2& result = Float64x2::Handle();
   {
-    RawObject* raw = Object::Allocate(Float64x2::kClassId,
-                                      Float64x2::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Float64x2::kClassId, Float64x2::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_x(value0);
   result.set_y(value1);
   return result.raw();
 }
 
 
 RawFloat64x2* Float64x2::New(simd128_value_t value, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
          Class::null());
   Float64x2& result = Float64x2::Handle();
   {
-    RawObject* raw = Object::Allocate(Float64x2::kClassId,
-                                      Float64x2::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Float64x2::kClassId, Float64x2::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 double Float64x2::x() const {
   return raw_ptr()->value_[0];
@@ skipping 26 matching lines @@
 
 
 const char* Float64x2::ToCString() const {
   double _x = x();
   double _y = y();
   return OS::SCreate(Thread::Current()->zone(), "[%f, %f]", _x, _y);
 }
 
 
 const intptr_t TypedData::element_size_table[TypedData::kNumElementSizes] = {
-  1,   // kTypedDataInt8ArrayCid.
-  1,   // kTypedDataUint8ArrayCid.
-  1,   // kTypedDataUint8ClampedArrayCid.
-  2,   // kTypedDataInt16ArrayCid.
-  2,   // kTypedDataUint16ArrayCid.
-  4,   // kTypedDataInt32ArrayCid.
-  4,   // kTypedDataUint32ArrayCid.
-  8,   // kTypedDataInt64ArrayCid.
-  8,   // kTypedDataUint64ArrayCid.
-  4,   // kTypedDataFloat32ArrayCid.
-  8,   // kTypedDataFloat64ArrayCid.
-  16,  // kTypedDataFloat32x4ArrayCid.
-  16,  // kTypedDataInt32x4ArrayCid.
-  16,  // kTypedDataFloat64x2ArrayCid,
+    1,   // kTypedDataInt8ArrayCid.
+    1,   // kTypedDataUint8ArrayCid.
+    1,   // kTypedDataUint8ClampedArrayCid.
+    2,   // kTypedDataInt16ArrayCid.
+    2,   // kTypedDataUint16ArrayCid.
+    4,   // kTypedDataInt32ArrayCid.
+    4,   // kTypedDataUint32ArrayCid.
+    8,   // kTypedDataInt64ArrayCid.
+    8,   // kTypedDataUint64ArrayCid.
+    4,   // kTypedDataFloat32ArrayCid.
+    8,   // kTypedDataFloat64ArrayCid.
+    16,  // kTypedDataFloat32x4ArrayCid.
+    16,  // kTypedDataInt32x4ArrayCid.
+    16,  // kTypedDataFloat64x2ArrayCid,
 };
 
 
 bool TypedData::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsTypedData() || other.IsNull()) {
     return false;
   }
 
   const TypedData& other_typed_data = TypedData::Cast(other);
 
   if (this->ElementType() != other_typed_data.ElementType()) {
     return false;
   }
 
   const intptr_t len = this->LengthInBytes();
   if (len != other_typed_data.LengthInBytes()) {
     return false;
   }
   NoSafepointScope no_safepoint;
   return (len == 0) ||
-      (memcmp(DataAddr(0), other_typed_data.DataAddr(0), len) == 0);
+         (memcmp(DataAddr(0), other_typed_data.DataAddr(0), len) == 0);
 }
 
 
 uword TypedData::ComputeCanonicalTableHash() const {
   const intptr_t len = this->LengthInBytes();
   ASSERT(len != 0);
   uword hash = len;
   for (intptr_t i = 0; i < len; i++) {
     hash = CombineHashes(len, GetUint8(i));
   }
   return FinalizeHash(hash, kHashBits);
 }
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   if (len < 0 || len > TypedData::MaxElements(class_id)) {
     FATAL1("Fatal error in TypedData::New: invalid len %" Pd "\n", len);
   }
   TypedData& result = TypedData::Handle();
   {
     const intptr_t lengthInBytes = len * ElementSizeInBytes(class_id);
-    RawObject* raw = Object::Allocate(class_id,
-                                      TypedData::InstanceSize(lengthInBytes),
-                                      space);
+    RawObject* raw = Object::Allocate(
+        class_id, TypedData::InstanceSize(lengthInBytes), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     if (len > 0) {
       memset(result.DataAddr(0), 0, lengthInBytes);
     }
   }
   return result.raw();
 }
 
 
 RawTypedData* TypedData::EmptyUint32Array(Thread* thread) {
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ASSERT(isolate->object_store() != NULL);
   if (isolate->object_store()->empty_uint32_array() != TypedData::null()) {
     // Already created.
     return isolate->object_store()->empty_uint32_array();
   }
-  const TypedData& array = TypedData::Handle(thread->zone(),
-      TypedData::New(kTypedDataUint32ArrayCid, 0, Heap::kOld));
+  const TypedData& array = TypedData::Handle(
+      thread->zone(), TypedData::New(kTypedDataUint32ArrayCid, 0, Heap::kOld));
   isolate->object_store()->set_empty_uint32_array(array);
   return array.raw();
 }
 
 
 const char* TypedData::ToCString() const {
   switch (GetClassId()) {
 #define CASE_TYPED_DATA_CLASS(clazz)                                           \
-  case kTypedData##clazz##Cid: return #clazz;
-  CLASS_LIST_TYPED_DATA(CASE_TYPED_DATA_CLASS);
+  case kTypedData##clazz##Cid:                                                 \
+    return #clazz;
+    CLASS_LIST_TYPED_DATA(CASE_TYPED_DATA_CLASS);
 #undef CASE_TYPED_DATA_CLASS
   }
   return "TypedData";
 }
 
 
 FinalizablePersistentHandle* ExternalTypedData::AddFinalizer(
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback,
     intptr_t external_size) const {
   return dart::AddFinalizer(*this, peer, callback, external_size);
 }
 
 
 RawExternalTypedData* ExternalTypedData::New(intptr_t class_id,
                                              uint8_t* data,
                                              intptr_t len,
                                              Heap::Space space) {
   ExternalTypedData& result = ExternalTypedData::Handle();
   {
-    RawObject* raw = Object::Allocate(class_id,
-                                      ExternalTypedData::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(class_id, ExternalTypedData::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(len);
     result.SetData(data);
   }
   return result.raw();
 }
 
 
 const char* ExternalTypedData::ToCString() const {
   return "ExternalTypedData";
 }
 
 
 RawCapability* Capability::New(uint64_t id, Heap::Space space) {
   Capability& result = Capability::Handle();
   {
     RawObject* raw = Object::Allocate(Capability::kClassId,
-                                      Capability::InstanceSize(),
-                                      space);
+                                      Capability::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
   }
   return result.raw();
 }
 
 
 const char* Capability::ToCString() const {
   return "Capability";
 }
 
 
 RawReceivePort* ReceivePort::New(Dart_Port id,
                                  bool is_control_port,
                                  Heap::Space space) {
   ASSERT(id != ILLEGAL_PORT);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const SendPort& send_port =
       SendPort::Handle(zone, SendPort::New(id, thread->isolate()->origin_id()));
 
   ReceivePort& result = ReceivePort::Handle(zone);
   {
     RawObject* raw = Object::Allocate(ReceivePort::kClassId,
-                                      ReceivePort::InstanceSize(),
-                                      space);
+                                      ReceivePort::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StorePointer(&result.raw_ptr()->send_port_, send_port.raw());
   }
   if (is_control_port) {
     PortMap::SetPortState(id, PortMap::kControlPort);
   } else {
     PortMap::SetPortState(id, PortMap::kLivePort);
   }
   return result.raw();
 }
 
 
 const char* ReceivePort::ToCString() const {
   return "ReceivePort";
 }
 
 
 RawSendPort* SendPort::New(Dart_Port id, Heap::Space space) {
   return New(id, Isolate::Current()->origin_id(), space);
 }
 
 
 RawSendPort* SendPort::New(Dart_Port id,
                            Dart_Port origin_id,
                            Heap::Space space) {
   ASSERT(id != ILLEGAL_PORT);
   SendPort& result = SendPort::Handle();
   {
-    RawObject* raw = Object::Allocate(SendPort::kClassId,
-                                      SendPort::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(SendPort::kClassId, SendPort::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->id_, id);
     result.StoreNonPointer(&result.raw_ptr()->origin_id_, origin_id);
   }
   return result.raw();
 }
 
 
 const char* SendPort::ToCString() const {
   return "SendPort";
 }
 
 
 const char* Closure::ToCString() const {
   const Function& fun = Function::Handle(function());
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
-  return OS::SCreate(Thread::Current()->zone(),
-      "Closure: %s%s%s", fun_sig, from, fun_desc);
+  return OS::SCreate(Thread::Current()->zone(), "Closure: %s%s%s", fun_sig,
+                     from, fun_desc);
 }
 
 
 RawClosure* Closure::New(const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Closure& result = Closure::Handle();
   {
-    RawObject* raw = Object::Allocate(Closure::kClassId,
-                                      Closure::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(Closure::kClassId, Closure::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StorePointer(&result.raw_ptr()->function_, function.raw());
     result.StorePointer(&result.raw_ptr()->context_, context.raw());
   }
   return result.raw();
 }
 
 
 RawClosure* Closure::New() {
-  RawObject* raw = Object::Allocate(Closure::kClassId,
-                                    Closure::InstanceSize(),
-                                    Heap::kOld);
+  RawObject* raw =
+      Object::Allocate(Closure::kClassId, Closure::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawClosure*>(raw);
 }
 
 
 intptr_t Stacktrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
 
 RawFunction* Stacktrace::FunctionAtFrame(intptr_t frame_index) const {
   const Code& code = Code::Handle(CodeAtFrame(frame_index));
   return code.IsNull() ? Function::null() : code.function();
 }
 
 
 RawCode* Stacktrace::CodeAtFrame(intptr_t frame_index) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return reinterpret_cast<RawCode*>(code_array.At(frame_index));
 }
 
 
-void Stacktrace::SetCodeAtFrame(intptr_t frame_index,
-                                const Code& code) const {
+void Stacktrace::SetCodeAtFrame(intptr_t frame_index, const Code& code) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   code_array.SetAt(frame_index, code);
 }
 
 
 RawSmi* Stacktrace::PcOffsetAtFrame(intptr_t frame_index) const {
   const Array& pc_offset_array = Array::Handle(raw_ptr()->pc_offset_array_);
   return reinterpret_cast<RawSmi*>(pc_offset_array.At(frame_index));
 }
 
@@ skipping 24 matching lines @@
   return raw_ptr()->expand_inlined_;
 }
 
 
 RawStacktrace* Stacktrace::New(const Array& code_array,
                                const Array& pc_offset_array,
                                Heap::Space space) {
   Stacktrace& result = Stacktrace::Handle();
   {
     RawObject* raw = Object::Allocate(Stacktrace::kClassId,
-                                      Stacktrace::InstanceSize(),
-                                      space);
+                                      Stacktrace::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_code_array(code_array);
   result.set_pc_offset_array(pc_offset_array);
   result.set_expand_inlined(true);  // default.
   return result.raw();
 }
 
 
 const char* Stacktrace::ToCString() const {
   intptr_t idx = 0;
   return ToCStringInternal(&idx);
 }
 
 
 static intptr_t PrintOneStacktrace(Zone* zone,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
   const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
       String::Handle(zone, function.QualifiedUserVisibleName());
-  const String& url = String::Handle(zone,
-      script.IsNull() ? String::New("Kernel") : script.url());
+  const String& url = String::Handle(
+      zone, script.IsNull() ? String::New("Kernel") : script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (!script.IsNull() && token_pos.IsReal()) {
     if (script.HasSource()) {
       script.GetTokenLocation(token_pos, &line, &column);
     } else {
       script.GetTokenLocation(token_pos, &line, NULL);
     }
   }
   char* chars = NULL;
   if (column >= 0) {
-    chars = OS::SCreate(zone,
-        "#%-6" Pd " %s (%s:%" Pd ":%" Pd ")\n",
-        frame_index, function_name.ToCString(), url.ToCString(), line, column);
+    chars =
+        OS::SCreate(zone, "#%-6" Pd " %s (%s:%" Pd ":%" Pd ")\n", frame_index,
+                    function_name.ToCString(), url.ToCString(), line, column);
   } else if (line >= 0) {
-    chars = OS::SCreate(zone,
-        "#%-6" Pd " %s (%s:%" Pd ")\n",
-        frame_index, function_name.ToCString(), url.ToCString(), line);
+    chars = OS::SCreate(zone, "#%-6" Pd " %s (%s:%" Pd ")\n", frame_index,
+                        function_name.ToCString(), url.ToCString(), line);
   } else {
-    chars = OS::SCreate(zone,
-        "#%-6" Pd " %s (%s)\n",
-        frame_index, function_name.ToCString(), url.ToCString());
+    chars = OS::SCreate(zone, "#%-6" Pd " %s (%s)\n", frame_index,
+                        function_name.ToCString(), url.ToCString());
   }
   frame_strings->Add(chars);
   return strlen(chars);
 }
 
 
 const char* Stacktrace::ToCStringInternal(intptr_t* frame_index,
                                           intptr_t max_frames) const {
   Zone* zone = Thread::Current()->zone();
   Function& function = Function::Handle();
@@ skipping 16 matching lines @@
         frame_strings.Add(chars);
         total_len += truncated_len;
         ASSERT(PcOffsetAtFrame(i) != Smi::null());
         // To account for gap frames.
         (*frame_index) += Smi::Value(PcOffsetAtFrame(i));
       }
     } else {
       code = CodeAtFrame(i);
       ASSERT(function.raw() == code.function());
       uword pc = code.PayloadStart() + Smi::Value(PcOffsetAtFrame(i));
-      if (code.is_optimized() &&
-          expand_inlined() &&
+      if (code.is_optimized() && expand_inlined() &&
           !FLAG_precompiled_runtime) {
         // Traverse inlined frames.
         for (InlinedFunctionsIterator it(code, pc);
              !it.Done() && (*frame_index < max_frames); it.Advance()) {
           function = it.function();
           if (function.is_visible() || FLAG_show_invisible_frames) {
             code = it.code();
             ASSERT(function.raw() == code.function());
             uword pc = it.pc();
             ASSERT(pc != 0);
             ASSERT(code.PayloadStart() <= pc);
             ASSERT(pc < (code.PayloadStart() + code.Size()));
-            total_len += PrintOneStacktrace(
-                zone, &frame_strings, pc, function, code, *frame_index);
+            total_len += PrintOneStacktrace(zone, &frame_strings, pc, function,
+                                            code, *frame_index);
             (*frame_index)++;  // To account for inlined frames.
           }
         }
       } else {
         if (function.is_visible() || FLAG_show_invisible_frames) {
-          total_len += PrintOneStacktrace(
-              zone, &frame_strings, pc, function, code, *frame_index);
+          total_len += PrintOneStacktrace(zone, &frame_strings, pc, function,
+                                          code, *frame_index);
           (*frame_index)++;
         }
       }
     }
   }
 
   // Now concatenate the frame descriptions into a single C string.
   char* chars = zone->Alloc<char>(total_len + 1);
   intptr_t index = 0;
   for (intptr_t i = 0; i < frame_strings.length(); i++) {
-    index += OS::SNPrint((chars + index),
-                         (total_len + 1 - index),
-                         "%s",
+    index += OS::SNPrint((chars + index), (total_len + 1 - index), "%s",
                          frame_strings[i]);
   }
   chars[total_len] = '\0';
   return chars;
 }
 
 
 void RegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
@@ skipping 14 matching lines @@
 
 
 void RegExp::set_num_bracket_expressions(intptr_t value) const {
   StoreSmi(&raw_ptr()->num_bracket_expressions_, Smi::New(value));
 }
 
 
 RawRegExp* RegExp::New(Heap::Space space) {
   RegExp& result = RegExp::Handle();
   {
-    RawObject* raw = Object::Allocate(RegExp::kClassId,
-                                      RegExp::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(RegExp::kClassId, RegExp::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_type(kUnitialized);
     result.set_flags(0);
     result.set_num_registers(-1);
   }
   return result.raw();
 }
 
 
 void* RegExp::GetDataStartAddress() const {
   intptr_t addr = reinterpret_cast<intptr_t>(raw_ptr());
   return reinterpret_cast<void*>(addr + sizeof(RawRegExp));
 }
 
 
 RawRegExp* RegExp::FromDataStartAddress(void* data) {
   RegExp& regexp = RegExp::Handle();
   intptr_t addr = reinterpret_cast<intptr_t>(data) - sizeof(RawRegExp);
   regexp ^= RawObject::FromAddr(addr);
   return regexp.raw();
 }
 
 
 const char* RegExp::Flags() const {
   switch (flags()) {
-    case kGlobal | kIgnoreCase | kMultiLine :
-    case kIgnoreCase | kMultiLine :
+    case kGlobal | kIgnoreCase | kMultiLine:
+    case kIgnoreCase | kMultiLine:
       return "im";
-    case kGlobal | kIgnoreCase :
+    case kGlobal | kIgnoreCase:
     case kIgnoreCase:
       return "i";
-    case kGlobal | kMultiLine :
+    case kGlobal | kMultiLine:
     case kMultiLine:
       return "m";
     default:
       break;
   }
   return "";
 }
 
 
 bool RegExp::CanonicalizeEquals(const Instance& other) const {
@@ skipping 15 matching lines @@
       (is_ignore_case() != other_js.is_ignore_case()) ||
       (is_multi_line() != other_js.is_multi_line())) {
     return false;
   }
   return true;
 }
 
 
 const char* RegExp::ToCString() const {
   const String& str = String::Handle(pattern());
-  return OS::SCreate(Thread::Current()->zone(),
-      "RegExp: pattern=%s flags=%s", str.ToCString(), Flags());
+  return OS::SCreate(Thread::Current()->zone(), "RegExp: pattern=%s flags=%s",
+                     str.ToCString(), Flags());
 }
 
 
 RawWeakProperty* WeakProperty::New(Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->weak_property_class()
-         != Class::null());
+  ASSERT(Isolate::Current()->object_store()->weak_property_class() !=
+         Class::null());
   RawObject* raw = Object::Allocate(WeakProperty::kClassId,
-                                    WeakProperty::InstanceSize(),
-                                    space);
+                                    WeakProperty::InstanceSize(), space);
   RawWeakProperty* result = reinterpret_cast<RawWeakProperty*>(raw);
   result->ptr()->next_ = 0;  // Init the list to NULL.
   return result;
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
@@ skipping 32 matching lines @@
   ASSERT(Object::Handle(referent()).IsTypeParameter());
   return TypeParameter::Cast(Object::Handle(referent())).raw();
 }
 
 
 RawMirrorReference* MirrorReference::New(const Object& referent,
                                          Heap::Space space) {
   MirrorReference& result = MirrorReference::Handle();
   {
     RawObject* raw = Object::Allocate(MirrorReference::kClassId,
-                                      MirrorReference::InstanceSize(),
-                                      space);
+                                      MirrorReference::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_referent(referent);
   return result.raw();
 }
 
 
 const char* MirrorReference::ToCString() const {
   return "_MirrorReference";
@@ skipping 11 matching lines @@
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->tag_table() != GrowableObjectArray::null());
   // Canonicalize by name.
   UserTag& result = UserTag::Handle(FindTagInIsolate(thread, label));
   if (!result.IsNull()) {
     // Tag already exists, return existing instance.
     return result.raw();
   }
   if (TagTableIsFull(thread)) {
-    const String& error = String::Handle(
-        String::NewFormatted("UserTag instance limit (%" Pd ") reached.",
-                             UserTags::kMaxUserTags));
+    const String& error = String::Handle(String::NewFormatted(
+        "UserTag instance limit (%" Pd ") reached.", UserTags::kMaxUserTags));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, error);
     Exceptions::ThrowByType(Exceptions::kUnsupported, args);
   }
   // No tag with label exists, create and register with isolate tag table.
   {
-    RawObject* raw = Object::Allocate(UserTag::kClassId,
-                                      UserTag::InstanceSize(),
-                                      space);
+    RawObject* raw =
+        Object::Allocate(UserTag::kClassId, UserTag::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_label(label);
   AddTagToIsolate(thread, result);
   return result.raw();
 }
 
 
 RawUserTag* UserTag::DefaultTag() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   if (isolate->default_tag() != UserTag::null()) {
     // Already created.
     return isolate->default_tag();
   }
   // Create default tag.
-  const UserTag& result = UserTag::Handle(zone,
-                                          UserTag::New(Symbols::Default()));
+  const UserTag& result =
+      UserTag::Handle(zone, UserTag::New(Symbols::Default()));
   ASSERT(result.tag() == UserTags::kDefaultUserTag);
   isolate->set_default_tag(result);
   return result.raw();
 }
 
 
 RawUserTag* UserTag::FindTagInIsolate(Thread* thread, const String& label) {
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   ASSERT(isolate->tag_table() != GrowableObjectArray::null());
-  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
-      zone, isolate->tag_table());
+  const GrowableObjectArray& tag_table =
+      GrowableObjectArray::Handle(zone, isolate->tag_table());
   UserTag& other = UserTag::Handle(zone);
   String& tag_label = String::Handle(zone);
   for (intptr_t i = 0; i < tag_table.Length(); i++) {
     other ^= tag_table.At(i);
     ASSERT(!other.IsNull());
     tag_label ^= other.label();
     ASSERT(!tag_label.IsNull());
     if (tag_label.Equals(label)) {
       return other.raw();
     }
   }
   return UserTag::null();
 }
 
 
 void UserTag::AddTagToIsolate(Thread* thread, const UserTag& tag) {
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   ASSERT(isolate->tag_table() != GrowableObjectArray::null());
-  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
-      zone, isolate->tag_table());
+  const GrowableObjectArray& tag_table =
+      GrowableObjectArray::Handle(zone, isolate->tag_table());
   ASSERT(!TagTableIsFull(thread));
 #if defined(DEBUG)
   // Verify that no existing tag has the same tag id.
   UserTag& other = UserTag::Handle(thread->zone());
   for (intptr_t i = 0; i < tag_table.Length(); i++) {
     other ^= tag_table.At(i);
     ASSERT(!other.IsNull());
     ASSERT(tag.tag() != other.tag());
   }
 #endif
   // Generate the UserTag tag id by taking the length of the isolate's
   // tag table + kUserTagIdOffset.
   uword tag_id = tag_table.Length() + UserTags::kUserTagIdOffset;
   ASSERT(tag_id >= UserTags::kUserTagIdOffset);
   ASSERT(tag_id < (UserTags::kUserTagIdOffset + UserTags::kMaxUserTags));
   tag.set_tag(tag_id);
   tag_table.Add(tag);
 }
 
 
 bool UserTag::TagTableIsFull(Thread* thread) {
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->tag_table() != GrowableObjectArray::null());
-  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
-      thread->zone(), isolate->tag_table());
+  const GrowableObjectArray& tag_table =
+      GrowableObjectArray::Handle(thread->zone(), isolate->tag_table());
   ASSERT(tag_table.Length() <= UserTags::kMaxUserTags);
   return tag_table.Length() == UserTags::kMaxUserTags;
 }
 
 
 RawUserTag* UserTag::FindTagById(uword tag_id) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate->tag_table() != GrowableObjectArray::null());
-  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
-      zone, isolate->tag_table());
+  const GrowableObjectArray& tag_table =
+      GrowableObjectArray::Handle(zone, isolate->tag_table());
   UserTag& tag = UserTag::Handle(zone);
   for (intptr_t i = 0; i < tag_table.Length(); i++) {
     tag ^= tag_table.At(i);
     if (tag.tag() == tag_id) {
       return tag.raw();
     }
   }
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart