clang-format runtime/vm

runtime/vm/object.h

 // 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.
 
 #ifndef RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 11 matching lines @@
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
 #include "vm/thread.h"
 #include "vm/token_position.h"
 
 namespace dart {
 
 // Forward declarations.
-#define DEFINE_FORWARD_DECLARATION(clazz)                                      \
-  class clazz;
+#define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class ArgumentsDescriptor;
 class Assembler;
 class Closure;
 class Code;
 class DisassemblyFormatter;
 class DeoptInstr;
 class FinalizablePersistentHandle;
 class LocalScope;
 
-#define REUSABLE_FORWARD_DECLARATION(name)                                     \
-  class Reusable##name##HandleScope;
+#define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FORWARD_DECLARATION)
 #undef REUSABLE_FORWARD_DECLARATION
 
 class Symbols;
 
 #if defined(DEBUG)
 #define CHECK_HANDLE() CheckHandle();
 #else
 #define CHECK_HANDLE()
 #endif
 
 #define BASE_OBJECT_IMPLEMENTATION(object, super)                              \
- public:  /* NOLINT */                                                         \
+ public: /* NOLINT */                                                          \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   bool Is##object() const { return true; }                                     \
   static object& Handle(Zone* zone, Raw##object* raw_ptr) {                    \
-    object* obj =                                                              \
-      reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));              \
+    object* obj = reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));  \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
   static object& Handle() {                                                    \
     return Handle(Thread::Current()->zone(), object::null());                  \
   }                                                                            \
-  static object& Handle(Zone* zone) {                                          \
-    return Handle(zone, object::null());                                       \
-  }                                                                            \
+  static object& Handle(Zone* zone) { return Handle(zone, object::null()); }   \
   static object& Handle(Raw##object* raw_ptr) {                                \
     return Handle(Thread::Current()->zone(), raw_ptr);                         \
   }                                                                            \
   static object& CheckedHandle(Zone* zone, RawObject* raw_ptr) {               \
-    object* obj =                                                              \
-        reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));            \
+    object* obj = reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));  \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
-      FATAL2("Handle check failed: saw %s expected %s",                        \
-             obj->ToCString(), #object);                                       \
+      FATAL2("Handle check failed: saw %s expected %s", obj->ToCString(),      \
+             #object);                                                         \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedHandle(RawObject* raw_ptr) {                           \
     return CheckedHandle(Thread::Current()->zone(), raw_ptr);                  \
   }                                                                            \
   static object& ZoneHandle(Zone* zone, Raw##object* raw_ptr) {                \
-    object* obj = reinterpret_cast<object*>(                                   \
-        VMHandles::AllocateZoneHandle(zone));                                  \
+    object* obj =                                                              \
+        reinterpret_cast<object*>(VMHandles::AllocateZoneHandle(zone));        \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
   static object* ReadOnlyHandle() {                                            \
-    object* obj = reinterpret_cast<object*>(                                   \
-        Dart::AllocateReadOnlyHandle());                                       \
+    object* obj = reinterpret_cast<object*>(Dart::AllocateReadOnlyHandle());   \
     initializeHandle(obj, object::null());                                     \
     return obj;                                                                \
   }                                                                            \
   static object& ZoneHandle(Zone* zone) {                                      \
     return ZoneHandle(zone, object::null());                                   \
   }                                                                            \
   static object& ZoneHandle() {                                                \
     return ZoneHandle(Thread::Current()->zone(), object::null());              \
   }                                                                            \
   static object& ZoneHandle(Raw##object* raw_ptr) {                            \
     return ZoneHandle(Thread::Current()->zone(), raw_ptr);                     \
   }                                                                            \
   static object& CheckedZoneHandle(Zone* zone, RawObject* raw_ptr) {           \
-    object* obj = reinterpret_cast<object*>(                                   \
-        VMHandles::AllocateZoneHandle(zone));                                  \
+    object* obj =                                                              \
+        reinterpret_cast<object*>(VMHandles::AllocateZoneHandle(zone));        \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
-      FATAL2("Handle check failed: saw %s expected %s",                        \
-             obj->ToCString(), #object);                                       \
+      FATAL2("Handle check failed: saw %s expected %s", obj->ToCString(),      \
+             #object);                                                         \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedZoneHandle(RawObject* raw_ptr) {                       \
     return CheckedZoneHandle(Thread::Current()->zone(), raw_ptr);              \
   }                                                                            \
   /* T::Cast cannot be applied to a null Object, because the object vtable */  \
   /* is not setup for type T, although some methods are supposed to work   */  \
   /* with null, for example Instance::Equals().                            */  \
   static const object& Cast(const Object& obj) {                               \
     ASSERT(obj.Is##object());                                                  \
     return reinterpret_cast<const object&>(obj);                               \
   }                                                                            \
   static Raw##object* RawCast(RawObject* raw) {                                \
     ASSERT(Object::Handle(raw).Is##object());                                  \
     return reinterpret_cast<Raw##object*>(raw);                                \
   }                                                                            \
   static Raw##object* null() {                                                 \
     return reinterpret_cast<Raw##object*>(Object::null());                     \
   }                                                                            \
   virtual const char* ToCString() const;                                       \
   static const ClassId kClassId = k##object##Cid;                              \
- private:  /* NOLINT */                                                        \
+                                                                               \
+ private: /* NOLINT */                                                         \
   /* Initialize the handle based on the raw_ptr in the presence of null. */    \
   static void initializeHandle(object* obj, RawObject* raw_ptr) {              \
     if (raw_ptr != Object::null()) {                                           \
       obj->SetRaw(raw_ptr);                                                    \
     } else {                                                                   \
       obj->raw_ = Object::null();                                              \
       object fake_object;                                                      \
       obj->set_vtable(fake_object.vtable());                                   \
     }                                                                          \
   }                                                                            \
   /* Disallow allocation, copy constructors and override super assignment. */  \
- public:  /* NOLINT */                                                         \
-  void operator delete(void* pointer) {                                        \
-    UNREACHABLE();                                                             \
-  }                                                                            \
- private:  /* NOLINT */                                                        \
+ public: /* NOLINT */                                                          \
+  void operator delete(void* pointer) { UNREACHABLE(); }                       \
+                                                                               \
+ private: /* NOLINT */                                                         \
   void* operator new(size_t size);                                             \
   object(const object& value);                                                 \
   void operator=(Raw##super* value);                                           \
   void operator=(const object& value);                                         \
-  void operator=(const super& value);                                          \
+  void operator=(const super& value);
 
 // Conditionally include object_service.cc functionality in the vtable to avoid
 // link errors like the following:
 //
 // object.o:(.rodata._ZTVN4....E[_ZTVN4...E]+0x278):
 // undefined reference to
 // `dart::Instance::PrintSharedInstanceJSON(dart::JSONObject*, bool) const'.
 //
 #ifndef PRODUCT
 #define OBJECT_SERVICE_SUPPORT(object)                                         \
-   protected:  /* NOLINT */                                                    \
+ protected: /* NOLINT */                                                       \
   /* Object is printed as JSON into stream. If ref is true only a header */    \
   /* with an object id is printed. If ref is false the object is fully   */    \
   /* printed.                                                            */    \
-    virtual void PrintJSONImpl(JSONStream* stream, bool ref) const;            \
-    virtual const char* JSONType() const {                                     \
-      return ""#object;                                                        \
-    }
+  virtual void PrintJSONImpl(JSONStream* stream, bool ref) const;              \
+  virtual const char* JSONType() const { return "" #object; }
 #else
-#define OBJECT_SERVICE_SUPPORT(object)                                         \
-   protected:  /* NOLINT */
-#endif  // !PRODUCT
+#define OBJECT_SERVICE_SUPPORT(object) protected: /* NOLINT */
+#endif                                            // !PRODUCT
 
 #define SNAPSHOT_READER_SUPPORT(object)                                        \
-  static Raw##object* ReadFrom(SnapshotReader* reader,                         \
-                               intptr_t object_id,                             \
-                               intptr_t tags,                                  \
-                               Snapshot::Kind,                                 \
+  static Raw##object* ReadFrom(SnapshotReader* reader, intptr_t object_id,     \
+                               intptr_t tags, Snapshot::Kind,                  \
                                bool as_reference);                             \
-  friend class SnapshotReader;                                                 \
+  friend class SnapshotReader;
 
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
- public:  /* NOLINT */                                                         \
-  void operator=(Raw##object* value) {                                         \
-    initializeHandle(this, value);                                             \
-  }                                                                            \
+ public: /* NOLINT */                                                          \
+  void operator=(Raw##object* value) { initializeHandle(this, value); }        \
   void operator^=(RawObject* value) {                                          \
     initializeHandle(this, value);                                             \
     ASSERT(IsNull() || Is##object());                                          \
   }                                                                            \
- protected:  /* NOLINT */                                                      \
+                                                                               \
+ protected: /* NOLINT */                                                       \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
   OBJECT_SERVICE_SUPPORT(object)
 
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   const Raw##object* raw_ptr() const {                                         \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class StackFrame;                                                     \
-  friend class Thread;                                                         \
+  friend class Thread;
 
 // This macro is used to denote types that do not have a sub-type.
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, rettype, super)        \
- public:  /* NOLINT */                                                         \
+ public: /* NOLINT */                                                          \
   void operator=(Raw##object* value) {                                         \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
   void operator^=(RawObject* value) {                                          \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
- private:  /* NOLINT */                                                        \
+                                                                               \
+ private: /* NOLINT */                                                         \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
   OBJECT_SERVICE_SUPPORT(object)                                               \
   const Raw##object* raw_ptr() const {                                         \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
-  static intptr_t NextFieldOffset() {                                          \
-    return -kWordSize;                                                         \
-  }                                                                            \
+  static intptr_t NextFieldOffset() { return -kWordSize; }                     \
   SNAPSHOT_READER_SUPPORT(rettype)                                             \
   friend class StackFrame;                                                     \
-  friend class Thread;                                                         \
+  friend class Thread;
 
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION(object, super)                        \
-  FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, object, super)               \
+  FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, object, super)
 
 #define MINT_OBJECT_IMPLEMENTATION(object, rettype, super)                     \
-  FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, rettype, super)              \
+  FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, rettype, super)
 
 class Object {
  public:
-  virtual ~Object() { }
+  virtual ~Object() {}
 
   RawObject* raw() const { return raw_; }
-  void operator=(RawObject* value) {
-    initializeHandle(this, value);
-  }
+  void operator=(RawObject* value) { initializeHandle(this, value); }
 
   uword CompareAndSwapTags(uword old_tags, uword new_tags) const {
-    return AtomicOperations::CompareAndSwapWord(
-        &raw()->ptr()->tags_, old_tags, new_tags);
+    return AtomicOperations::CompareAndSwapWord(&raw()->ptr()->tags_, old_tags,
+                                                new_tags);
   }
-  bool IsCanonical() const {
-    return raw()->IsCanonical();
-  }
-  void SetCanonical() const {
-    raw()->SetCanonical();
-  }
-  void ClearCanonical() const {
-    raw()->ClearCanonical();
-  }
+  bool IsCanonical() const { return raw()->IsCanonical(); }
+  void SetCanonical() const { raw()->SetCanonical(); }
+  void ClearCanonical() const { raw()->ClearCanonical(); }
   intptr_t GetClassId() const {
-    return !raw()->IsHeapObject() ?
-        static_cast<intptr_t>(kSmiCid) : raw()->GetClassId();
+    return !raw()->IsHeapObject() ? static_cast<intptr_t>(kSmiCid)
+                                  : raw()->GetClassId();
   }
   inline RawClass* clazz() const;
   static intptr_t tags_offset() { return OFFSET_OF(RawObject, tags_); }
 
-  // Class testers.
+// Class testers.
 #define DEFINE_CLASS_TESTER(clazz)                                             \
   virtual bool Is##clazz() const { return false; }
   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
 #undef DEFINE_CLASS_TESTER
 
   bool IsNull() const { return raw_ == null_; }
 
   // Matches Object.toString on instances (except String::ToCString, bug 20583).
   virtual const char* ToCString() const {
     if (IsNull()) {
       return "null";
     } else {
       return "Object";
     }
   }
 
 #ifndef PRODUCT
   void PrintJSON(JSONStream* stream, bool ref = true) const;
   virtual void PrintJSONImpl(JSONStream* stream, bool ref) const;
-  virtual const char* JSONType() const {
-    return IsNull() ? "null" : "Object";
-  }
+  virtual const char* JSONType() const { return IsNull() ? "null" : "Object"; }
 #endif
 
   // Returns the name that is used to identify an object in the
   // namespace dictionary.
   // Object::DictionaryName() returns String::null(). Only subclasses
   // of Object that need to be entered in the library and library prefix
   // namespaces need to provide an implementation.
   virtual RawString* DictionaryName() const;
 
   bool IsNew() const { return raw()->IsNewObject(); }
@@ skipping 14 matching lines @@
   bool IsReadOnlyHandle() const;
 
   bool IsNotTemporaryScopedHandle() const;
 
   static Object& Handle(Zone* zone, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(zone));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
   static Object* ReadOnlyHandle() {
-    Object* obj = reinterpret_cast<Object*>(
-        Dart::AllocateReadOnlyHandle());
+    Object* obj = reinterpret_cast<Object*>(Dart::AllocateReadOnlyHandle());
     initializeHandle(obj, Object::null());
     return obj;
   }
 
-  static Object& Handle() {
-    return Handle(Thread::Current()->zone(), null_);
-  }
+  static Object& Handle() { return Handle(Thread::Current()->zone(), null_); }
 
-  static Object& Handle(Zone* zone) {
-    return Handle(zone, null_);
-  }
+  static Object& Handle(Zone* zone) { return Handle(zone, null_); }
 
   static Object& Handle(RawObject* raw_ptr) {
     return Handle(Thread::Current()->zone(), raw_ptr);
   }
 
   static Object& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
-    Object* obj = reinterpret_cast<Object*>(
-        VMHandles::AllocateZoneHandle(zone));
+    Object* obj =
+        reinterpret_cast<Object*>(VMHandles::AllocateZoneHandle(zone));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& ZoneHandle() {
     return ZoneHandle(Thread::Current()->zone(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Thread::Current()->zone(), raw_ptr);
@@ skipping 196 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawObject));
   }
 
   static void VerifyBuiltinVtables();
 
   static const ClassId kClassId = kObjectCid;
 
   // Different kinds of type tests.
-  enum TypeTestKind {
-    kIsSubtypeOf = 0,
-    kIsMoreSpecificThan
-  };
+  enum TypeTestKind { kIsSubtypeOf = 0, kIsMoreSpecificThan };
 
   // Different kinds of name visibility.
   enum NameVisibility {
     // Internal names are the true names of classes, fields,
     // etc. inside the vm.  These names include privacy suffixes,
     // getter prefixes, and trailing dots on unnamed constructors.
     //
     // The names of core implementation classes (like _OneByteString)
     // are preserved as well.
     //
@@ skipping 25 matching lines @@
     //   _MyClass@6b3832b.      -> _MyClass
     //   _MyClass@6b3832b.named -> _MyClass.named
     //   _OneByteString         -> String (remapped)
     kUserVisibleName
   };
 
  protected:
   // Used for extracting the C++ vtable during bringup.
   Object() : raw_(null_) {}
 
-  uword raw_value() const {
-    return reinterpret_cast<uword>(raw());
-  }
+  uword raw_value() const { return reinterpret_cast<uword>(raw()); }
 
   inline void SetRaw(RawObject* value);
   void CheckHandle() const;
 
   cpp_vtable vtable() const { return bit_copy<cpp_vtable>(*this); }
   void set_vtable(cpp_vtable value) { *vtable_address() = value; }
 
-  static RawObject* Allocate(intptr_t cls_id,
-                             intptr_t size,
-                             Heap::Space space);
+  static RawObject* Allocate(intptr_t cls_id, intptr_t size, Heap::Space space);
 
   static intptr_t RoundedAllocationSize(intptr_t size) {
     return Utils::RoundUp(size, kObjectAlignment);
   }
 
   bool Contains(uword addr) const { return raw()->Contains(addr); }
 
   // Start of field mutator guards.
   //
   // All writes to heap objects should ultimately pass through one of the
   // methods below or their counterparts in RawObject, to ensure that the
   // write barrier is correctly applied.
 
-  template<typename type>
+  template <typename type>
   void StorePointer(type const* addr, type value) const {
     raw()->StorePointer(addr, value);
   }
 
   // Store a range of pointers [from, from + count) into [to, to + count).
   // TODO(koda): Use this to fix Object::Clone's broken store buffer logic.
   void StorePointers(RawObject* const* to,
                      RawObject* const* from,
                      intptr_t count) {
     ASSERT(Contains(reinterpret_cast<uword>(to)));
     if (raw()->IsNewObject()) {
       memmove(const_cast<RawObject**>(to), from, count * kWordSize);
     } else {
       for (intptr_t i = 0; i < count; ++i) {
         StorePointer(&to[i], from[i]);
       }
     }
   }
 
   // Use for storing into an explicitly Smi-typed field of an object
   // (i.e., both the previous and new value are Smis).
   void StoreSmi(RawSmi* const* addr, RawSmi* value) const {
     raw()->StoreSmi(addr, value);
   }
 
-  template<typename FieldType>
+  template <typename FieldType>
   void StoreSimd128(const FieldType* addr, simd128_value_t value) const {
     ASSERT(Contains(reinterpret_cast<uword>(addr)));
     value.writeTo(const_cast<FieldType*>(addr));
   }
 
   // Needs two template arguments to allow assigning enums to fixed-size ints.
-  template<typename FieldType, typename ValueType>
+  template <typename FieldType, typename ValueType>
   void StoreNonPointer(const FieldType* addr, ValueType value) const {
     // Can't use Contains, as it uses tags_, which is set through this method.
     ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(raw()));
     *const_cast<FieldType*>(addr) = value;
   }
 
   // Provides non-const access to non-pointer fields within the object. Such
   // access does not need a write barrier, but it is *not* GC-safe, since the
   // object might move, hence must be fully contained within a NoSafepointScope.
-  template<typename FieldType>
+  template <typename FieldType>
   FieldType* UnsafeMutableNonPointer(const FieldType* addr) const {
     // Allow pointers at the end of variable-length data, and disallow pointers
     // within the header word.
     ASSERT(Contains(reinterpret_cast<uword>(addr) - 1) &&
            Contains(reinterpret_cast<uword>(addr) - kWordSize));
     // At least check that there is a NoSafepointScope and hope it's big enough.
     ASSERT(Thread::Current()->no_safepoint_scope_depth() > 0);
     return const_cast<FieldType*>(addr);
   }
 
-  // Fail at link time if StoreNonPointer or UnsafeMutableNonPointer is
-  // instantiated with an object pointer type.
+// Fail at link time if StoreNonPointer or UnsafeMutableNonPointer is
+// instantiated with an object pointer type.
 #define STORE_NON_POINTER_ILLEGAL_TYPE(type)                                   \
-  template<typename ValueType>                                                 \
+  template <typename ValueType>                                                \
   void StoreNonPointer(Raw##type* const* addr, ValueType value) const {        \
     UnimplementedMethod();                                                     \
   }                                                                            \
   Raw##type** UnsafeMutableNonPointer(Raw##type* const* addr) const {          \
     UnimplementedMethod();                                                     \
     return NULL;                                                               \
   }
 
   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
   void UnimplementedMethod() const;
@@ skipping 45 matching lines @@
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
   static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
 
-  static RawClass* class_class_;  // Class of the Class vm object.
-  static RawClass* dynamic_class_;  // Class of the 'dynamic' type.
-  static RawClass* void_class_;  // Class of the 'void' type.
+  static RawClass* class_class_;             // Class of the Class vm object.
+  static RawClass* dynamic_class_;           // Class of the 'dynamic' type.
+  static RawClass* void_class_;              // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
-  static RawClass* patch_class_class_;  // Class of the PatchClass vm object.
-  static RawClass* function_class_;  // Class of the Function vm object.
-  static RawClass* closure_data_class_;  // Class of ClosureData vm obj.
+  static RawClass* patch_class_class_;     // Class of the PatchClass vm object.
+  static RawClass* function_class_;        // Class of the Function vm object.
+  static RawClass* closure_data_class_;    // Class of ClosureData vm obj.
   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
-  static RawClass* field_class_;  // Class of the Field vm object.
-  static RawClass* literal_token_class_;  // Class of LiteralToken vm object.
+  static RawClass* field_class_;             // Class of the Field vm object.
+  static RawClass* literal_token_class_;     // Class of LiteralToken vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
-  static RawClass* script_class_;  // Class of the Script vm object.
-  static RawClass* library_class_;  // Class of the Library vm object.
-  static RawClass* namespace_class_;  // Class of Namespace vm object.
-  static RawClass* code_class_;  // Class of the Code vm object.
+  static RawClass* script_class_;        // Class of the Script vm object.
+  static RawClass* library_class_;       // Class of the Library vm object.
+  static RawClass* namespace_class_;     // Class of Namespace vm object.
+  static RawClass* code_class_;          // Class of the Code vm object.
   static RawClass* instructions_class_;  // Class of the Instructions vm object.
-  static RawClass* object_pool_class_;  // Class of the ObjectPool vm object.
-  static RawClass* pc_descriptors_class_;  // Class of PcDescriptors vm object.
+  static RawClass* object_pool_class_;   // Class of the ObjectPool vm object.
+  static RawClass* pc_descriptors_class_;   // Class of PcDescriptors vm object.
   static RawClass* code_source_map_class_;  // Class of CodeSourceMap vm object.
-  static RawClass* stackmap_class_;  // Class of Stackmap vm object.
+  static RawClass* stackmap_class_;         // Class of Stackmap vm object.
   static RawClass* var_descriptors_class_;  // Class of LocalVarDescriptors.
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
-  static RawClass* deopt_info_class_;  // Class of DeoptInfo.
-  static RawClass* context_class_;  // Class of the Context vm object.
+  static RawClass* deopt_info_class_;          // Class of DeoptInfo.
+  static RawClass* context_class_;        // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
-  static RawClass* singletargetcache_class_;  // Class of SingleTargetCache.
-  static RawClass* unlinkedcall_class_;  // Class of UnlinkedCall.
-  static RawClass* icdata_class_;  // Class of ICData.
-  static RawClass* megamorphic_cache_class_;  // Class of MegamorphiCache.
-  static RawClass* subtypetestcache_class_;  // Class of SubtypeTestCache.
-  static RawClass* api_error_class_;  // Class of ApiError.
-  static RawClass* language_error_class_;  // Class of LanguageError.
+  static RawClass* singletargetcache_class_;    // Class of SingleTargetCache.
+  static RawClass* unlinkedcall_class_;         // Class of UnlinkedCall.
+  static RawClass* icdata_class_;               // Class of ICData.
+  static RawClass* megamorphic_cache_class_;    // Class of MegamorphiCache.
+  static RawClass* subtypetestcache_class_;     // Class of SubtypeTestCache.
+  static RawClass* api_error_class_;            // Class of ApiError.
+  static RawClass* language_error_class_;       // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
-  static RawClass* unwind_error_class_;  // Class of UnwindError.
+  static RawClass* unwind_error_class_;         // Class of UnwindError.
 
   // The static values below are read-only handle pointers for singleton
   // objects that are shared between the different isolates.
   static Object* null_object_;
   static Array* null_array_;
   static String* null_string_;
   static Instance* null_instance_;
   static TypeArguments* null_type_arguments_;
   static Array* empty_array_;
   static Array* zero_array_;
@@ skipping 25 matching lines @@
   friend class SnapshotReader;
   friend class InstanceDeserializationCluster;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   friend class Thread;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
-REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
+  REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class PassiveObject : public Object {
  public:
-  void operator=(RawObject* value) {
-    raw_ = value;
-  }
-  void operator^=(RawObject* value) {
-    raw_ = value;
-  }
+  void operator=(RawObject* value) { raw_ = value; }
+  void operator^=(RawObject* value) { raw_ = value; }
 
   static PassiveObject& Handle(Zone* zone, RawObject* raw_ptr) {
-    PassiveObject* obj = reinterpret_cast<PassiveObject*>(
-        VMHandles::AllocateHandle(zone));
+    PassiveObject* obj =
+        reinterpret_cast<PassiveObject*>(VMHandles::AllocateHandle(zone));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
   static PassiveObject& Handle(RawObject* raw_ptr) {
     return Handle(Thread::Current()->zone(), raw_ptr);
   }
   static PassiveObject& Handle() {
     return Handle(Thread::Current()->zone(), Object::null());
   }
   static PassiveObject& Handle(Zone* zone) {
     return Handle(zone, Object::null());
   }
   static PassiveObject& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
-    PassiveObject* obj = reinterpret_cast<PassiveObject*>(
-        VMHandles::AllocateZoneHandle(zone));
+    PassiveObject* obj =
+        reinterpret_cast<PassiveObject*>(VMHandles::AllocateZoneHandle(zone));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
   static PassiveObject& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Thread::Current()->zone(), raw_ptr);
   }
   static PassiveObject& ZoneHandle() {
     return ZoneHandle(Thread::Current()->zone(), Object::null());
   }
@@ skipping 90 matching lines @@
   // class C<R> extends B<R, int>
   // C.DeclarationType() --> C [R, int, R]
   RawAbstractType* DeclarationType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters (and their bounds) are specified as an array of
   // TypeParameter.
   RawTypeArguments* type_parameters() const {
-      return raw_ptr()->type_parameters_;
+    return raw_ptr()->type_parameters_;
   }
   void set_type_parameters(const TypeArguments& value) const;
   intptr_t NumTypeParameters(Thread* thread) const;
   intptr_t NumTypeParameters() const {
     return NumTypeParameters(Thread::Current());
   }
   static intptr_t type_parameters_offset() {
     return OFFSET_OF(RawClass, type_parameters_);
   }
 
@@ skipping 95 matching lines @@
   // Check if this class represents the 'void' class.
   bool IsVoidClass() const { return id() == kVoidCid; }
 
   // Check if this class represents the 'Object' class.
   bool IsObjectClass() const { return id() == kInstanceCid; }
 
   // Check if this class represents the 'Function' class.
   bool IsDartFunctionClass() const;
 
   // Check if this class represents the 'Closure' class.
-  bool IsClosureClass() const  { return id() == kClosureCid; }
+  bool IsClosureClass() const { return id() == kClosureCid; }
   static bool IsClosureClass(RawClass* cls) {
     NoSafepointScope no_safepoint;
     return cls->ptr()->id_ == kClosureCid;
   }
 
   // Check if this class represents a typedef class.
-  bool IsTypedefClass() const {
-    return signature_function() != Object::null();
-  }
+  bool IsTypedefClass() const { return signature_function() != Object::null(); }
 
   static bool IsInFullSnapshot(RawClass* cls) {
     NoSafepointScope no_safepoint;
     return cls->ptr()->library_->ptr()->is_in_fullsnapshot_;
   }
 
   // Check the subtype relationship.
   bool IsSubtypeOf(const TypeArguments& type_arguments,
                    const Class& other,
                    const TypeArguments& other_type_arguments,
                    Error* bound_error,
                    TrailPtr bound_trail,
                    Heap::Space space) const {
-    return TypeTest(kIsSubtypeOf,
-                    type_arguments,
-                    other,
-                    other_type_arguments,
-                    bound_error,
-                    bound_trail,
-                    space);
+    return TypeTest(kIsSubtypeOf, type_arguments, other, other_type_arguments,
+                    bound_error, bound_trail, space);
   }
 
   // Check the 'more specific' relationship.
   bool IsMoreSpecificThan(const TypeArguments& type_arguments,
                           const Class& other,
                           const TypeArguments& other_type_arguments,
                           Error* bound_error,
                           TrailPtr bound_trail,
                           Heap::Space space) const {
-    return TypeTest(kIsMoreSpecificThan,
-                    type_arguments,
-                    other,
-                    other_type_arguments,
-                    bound_error,
-                    bound_trail,
-                    space);
+    return TypeTest(kIsMoreSpecificThan, type_arguments, other,
+                    other_type_arguments, bound_error, bound_trail, space);
   }
 
   // Check if this is the top level class.
   bool IsTopLevel() const;
 
   bool IsPrivate() const;
 
   // Returns an array of instance and static fields defined by this class.
   RawArray* fields() const { return raw_ptr()->fields_; }
   void SetFields(const Array& value) const;
@@ skipping 37 matching lines @@
   RawField* LookupInstanceFieldAllowPrivate(const String& name) const;
   RawField* LookupStaticFieldAllowPrivate(const String& name) const;
 
   RawLibraryPrefix* LookupLibraryPrefix(const String& name) const;
 
   // 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* LookupCanonicalDouble(Zone* zone,
-                                   double value, intptr_t* index) const;
+                                   double value,
+                                   intptr_t* index) const;
   RawMint* LookupCanonicalMint(Zone* zone,
-                               int64_t value, intptr_t* index) const;
+                               int64_t value,
+                               intptr_t* index) const;
   RawBigint* LookupCanonicalBigint(Zone* zone,
-                                   const Bigint& value, intptr_t* index) const;
+                                   const Bigint& value,
+                                   intptr_t* index) const;
   // The methods above are more efficient than this generic one.
-  RawInstance* LookupCanonicalInstance(Zone* zone,
-                                       const Instance& value) const;
+  RawInstance* LookupCanonicalInstance(Zone* zone, const Instance& value) const;
 
   RawInstance* InsertCanonicalConstant(Zone* zone,
                                        const Instance& constant) const;
   void InsertCanonicalNumber(Zone* zone,
                              intptr_t index,
                              const Number& constant) const;
 
   void RehashConstants(Zone* zone) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClass));
   }
 
   bool is_implemented() const {
     return ImplementedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_implemented() const;
 
   bool is_abstract() const {
     return AbstractBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_abstract() const;
 
   bool is_type_finalized() const {
     return TypeFinalizedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_type_finalized() const;
 
-  bool is_patch() const {
-    return PatchBit::decode(raw_ptr()->state_bits_);
-  }
+  bool is_patch() const { return PatchBit::decode(raw_ptr()->state_bits_); }
   void set_is_patch() const;
 
   bool is_synthesized_class() const {
     return SynthesizedClassBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_synthesized_class() const;
 
-  bool is_enum_class() const {
-    return EnumBit::decode(raw_ptr()->state_bits_);
-  }
+  bool is_enum_class() const { return EnumBit::decode(raw_ptr()->state_bits_); }
   void set_is_enum_class() const;
 
   bool is_finalized() const {
-    return ClassFinalizedBits::decode(raw_ptr()->state_bits_)
-        == RawClass::kFinalized;
+    return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
+           RawClass::kFinalized;
   }
   void set_is_finalized() const;
 
   bool is_prefinalized() const {
-    return ClassFinalizedBits::decode(raw_ptr()->state_bits_)
-        == RawClass::kPreFinalized;
+    return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
+           RawClass::kPreFinalized;
   }
 
   void set_is_prefinalized() const;
 
   bool is_refinalize_after_patch() const {
-    return ClassFinalizedBits::decode(raw_ptr()->state_bits_)
-        == RawClass::kRefinalizeAfterPatch;
+    return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
+           RawClass::kRefinalizeAfterPatch;
   }
 
   void SetRefinalizeAfterPatch() const;
   void ResetFinalization() const;
 
   bool is_marked_for_parsing() const {
     return MarkedForParsingBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_marked_for_parsing() const;
   void reset_is_marked_for_parsing() const;
@@ skipping 19 matching lines @@
   bool is_cycle_free() const {
     return CycleFreeBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_cycle_free() const;
 
   bool is_allocated() const {
     return IsAllocatedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_allocated(bool value) const;
 
-  uint16_t num_native_fields() const {
-    return raw_ptr()->num_native_fields_;
-  }
+  uint16_t num_native_fields() const { return raw_ptr()->num_native_fields_; }
   void set_num_native_fields(uint16_t value) const {
     StoreNonPointer(&raw_ptr()->num_native_fields_, value);
   }
 
-  RawCode* allocation_stub() const {
-    return raw_ptr()->allocation_stub_;
-  }
+  RawCode* allocation_stub() const { return raw_ptr()->allocation_stub_; }
   void set_allocation_stub(const Code& value) const;
 
   void DisableAllocationStub() const;
 
   RawArray* constants() const;
   void set_constants(const Array& value) const;
 
   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
   RawFunction* InvocationDispatcherFunctionFromIndex(intptr_t idx) const;
 
@@ skipping 13 matching lines @@
   // error object if evaluating the expression fails. The method has
   // the formal parameters given in param_names, and is invoked with
   // the argument values given in param_values.
   RawObject* Evaluate(const String& expr,
                       const Array& param_names,
                       const Array& param_values) const;
 
   RawError* EnsureIsFinalized(Thread* thread) const;
 
   // Allocate a class used for VM internal objects.
-  template <class FakeObject> static RawClass* New();
+  template <class FakeObject>
+  static RawClass* New();
 
   // Allocate instance classes.
   static RawClass* New(const Library& lib,
                        const String& name,
                        const Script& script,
                        TokenPosition token_pos);
   static RawClass* NewNativeWrapper(const Library& library,
                                     const String& name,
                                     int num_fields);
 
@@ skipping 40 matching lines @@
 
  private:
   bool CanReloadFinalized(const Class& replacement,
                           IsolateReloadContext* context) const;
   bool CanReloadPreFinalized(const Class& replacement,
                              IsolateReloadContext* context) const;
 
   // Tells whether instances need morphing for reload.
   bool RequiresInstanceMorphing(const Class& replacement) const;
 
-  template <class FakeObject> static RawClass* NewCommon(intptr_t index);
+  template <class FakeObject>
+  static RawClass* NewCommon(intptr_t index);
 
   enum MemberKind {
     kAny = 0,
     kStatic,
     kInstance,
     kInstanceAllowAbstract,
     kConstructor,
     kFactory,
   };
   enum StateBits {
     kConstBit = 0,
     kImplementedBit = 1,
     kTypeFinalizedBit = 2,
     kClassFinalizedPos = 3,
     kClassFinalizedSize = 2,
     kAbstractBit = kClassFinalizedPos + kClassFinalizedSize,  // = 5
     kPatchBit = 6,
     kSynthesizedClassBit = 7,
     kMarkedForParsingBit = 8,
     kMixinAppAliasBit = 9,
     kMixinTypeAppliedBit = 10,
     kFieldsMarkedNullableBit = 11,
     kCycleFreeBit = 12,
     kEnumBit = 13,
     kIsAllocatedBit = 15,
   };
   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
   class ImplementedBit : public BitField<uint16_t, bool, kImplementedBit, 1> {};
-  class TypeFinalizedBit :
-      public BitField<uint16_t, bool, kTypeFinalizedBit, 1> {};
+  class TypeFinalizedBit
+      : public BitField<uint16_t, bool, kTypeFinalizedBit, 1> {};
   class ClassFinalizedBits : public BitField<uint16_t,
                                              RawClass::ClassFinalizedState,
                                              kClassFinalizedPos,
                                              kClassFinalizedSize> {};
   class AbstractBit : public BitField<uint16_t, bool, kAbstractBit, 1> {};
   class PatchBit : public BitField<uint16_t, bool, kPatchBit, 1> {};
-  class SynthesizedClassBit :
-      public BitField<uint16_t, bool, kSynthesizedClassBit, 1> {};
-  class MarkedForParsingBit :
-      public BitField<uint16_t, bool, kMarkedForParsingBit, 1> {};
-  class MixinAppAliasBit :
-      public BitField<uint16_t, bool, kMixinAppAliasBit, 1> {};
-  class MixinTypeAppliedBit :
-      public BitField<uint16_t, bool, kMixinTypeAppliedBit, 1> {};
-  class FieldsMarkedNullableBit :
-      public BitField<uint16_t, bool, kFieldsMarkedNullableBit, 1> {};
+  class SynthesizedClassBit
+      : public BitField<uint16_t, bool, kSynthesizedClassBit, 1> {};
+  class MarkedForParsingBit
+      : public BitField<uint16_t, bool, kMarkedForParsingBit, 1> {};
+  class MixinAppAliasBit
+      : public BitField<uint16_t, bool, kMixinAppAliasBit, 1> {};
+  class MixinTypeAppliedBit
+      : public BitField<uint16_t, bool, kMixinTypeAppliedBit, 1> {};
+  class FieldsMarkedNullableBit
+      : public BitField<uint16_t, bool, kFieldsMarkedNullableBit, 1> {};
   class CycleFreeBit : public BitField<uint16_t, bool, kCycleFreeBit, 1> {};
   class EnumBit : public BitField<uint16_t, bool, kEnumBit, 1> {};
   class IsAllocatedBit : public BitField<uint16_t, bool, kIsAllocatedBit, 1> {};
 
   void set_name(const String& value) const;
   void set_user_name(const String& value) const;
   RawString* GenerateUserVisibleName() const;
   void set_state_bits(intptr_t bits) const;
 
   void set_canonical_type(const Type& value) const;
   RawType* canonical_type() const;
 
   RawArray* invocation_dispatcher_cache() const;
   void set_invocation_dispatcher_cache(const Array& cache) const;
   RawFunction* CreateInvocationDispatcher(const String& target_name,
                                           const Array& args_desc,
                                           RawFunction::Kind kind) const;
 
   void CalculateFieldOffsets() const;
 
   // functions_hash_table is in use iff there are at least this many functions.
   static const intptr_t kFunctionLookupHashTreshold = 16;
 
   // Initial value for the cached number of type arguments.
   static const intptr_t kUnknownNumTypeArguments = -1;
 
-  int16_t num_type_arguments() const {
-    return raw_ptr()->num_type_arguments_;
-  }
+  int16_t num_type_arguments() const { return raw_ptr()->num_type_arguments_; }
   void set_num_type_arguments(intptr_t value) const;
   static intptr_t num_type_arguments_offset() {
     return OFFSET_OF(RawClass, num_type_arguments_);
   }
 
   int16_t num_own_type_arguments() const {
     return raw_ptr()->num_own_type_arguments_;
   }
   void set_num_own_type_arguments(intptr_t value) const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   static RawFunction* CheckFunctionType(const Function& func, MemberKind kind);
   RawFunction* LookupFunction(const String& name, MemberKind kind) const;
   RawFunction* LookupFunctionAllowPrivate(const String& name,
                                           MemberKind kind) const;
   RawField* LookupField(const String& name, MemberKind kind) const;
 
   RawFunction* LookupAccessorFunction(const char* prefix,
                                       intptr_t prefix_length,
                                       const String& name) const;
 
   // Allocate an instance class which has a VM implementation.
-  template <class FakeInstance> static RawClass* New(intptr_t id);
+  template <class FakeInstance>
+  static RawClass* New(intptr_t id);
 
   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
   static RawClass* NewInstanceClass();
 
   // Check the subtype or 'more specific' relationship.
   bool 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;
 
-  static bool TypeTestNonRecursive(
-      const Class& cls,
-      TypeTestKind test_kind,
-      const TypeArguments& type_arguments,
-      const Class& other,
-      const TypeArguments& other_type_arguments,
-      Error* bound_error,
-      TrailPtr bound_trail,
-      Heap::Space space);
+  static bool TypeTestNonRecursive(const Class& cls,
+                                   TypeTestKind test_kind,
+                                   const TypeArguments& type_arguments,
+                                   const Class& other,
+                                   const TypeArguments& other_type_arguments,
+                                   Error* bound_error,
+                                   TrailPtr bound_trail,
+                                   Heap::Space space);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class AbstractType;
   friend class Instance;
   friend class Object;
   friend class Type;
   friend class Intrinsifier;
   friend class Precompiler;
 };
 
@@ skipping 34 matching lines @@
 class TypeArguments : public Object {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   intptr_t Length() const;
   RawAbstractType* TypeAt(intptr_t index) const;
   static intptr_t type_at_offset(intptr_t index) {
-    return OFFSET_OF_RETURNED_VALUE(
-        RawTypeArguments, types) + index * kWordSize;
+    return OFFSET_OF_RETURNED_VALUE(RawTypeArguments, types) +
+           index * kWordSize;
   }
   void SetTypeAt(intptr_t index, const AbstractType& value) const;
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>".
-  RawString* Name() const {
-    return SubvectorName(0, Length(), kInternalName);
-  }
+  RawString* Name() const { return SubvectorName(0, Length(), kInternalName); }
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, int>".
   // Names of internal classes are mapped to their public interfaces.
   RawString* UserVisibleName() const {
     return SubvectorName(0, Length(), kUserVisibleName);
   }
 
   // Check if the subvector of length 'len' starting at 'from_index' of this
   // type argument vector consists solely of DynamicType.
   bool IsRaw(intptr_t from_index, intptr_t len) const {
     return IsDynamicTypes(false, from_index, len);
   }
 
   // Check if this type argument vector would consist solely of DynamicType if
   // it was instantiated from a raw (null) instantiator, i.e. consider each type
   // parameter as it would be first instantiated from a vector of dynamic types.
   // Consider only a prefix of length 'len'.
   bool IsRawInstantiatedRaw(intptr_t len) const {
     return IsDynamicTypes(true, 0, len);
   }
 
   // Check the subtype relationship, considering only a subvector of length
   // 'len' starting at 'from_index'.
   bool IsSubtypeOf(const TypeArguments& other,
                    intptr_t from_index,
                    intptr_t len,
                    Error* bound_error,
                    TrailPtr bound_trail,
                    Heap::Space space) const {
-    return TypeTest(kIsSubtypeOf, other, from_index, len,
-                    bound_error, bound_trail, space);
+    return TypeTest(kIsSubtypeOf, other, from_index, len, bound_error,
+                    bound_trail, space);
   }
 
   // Check the 'more specific' relationship, considering only a subvector of
   // length 'len' starting at 'from_index'.
   bool IsMoreSpecificThan(const TypeArguments& other,
                           intptr_t from_index,
                           intptr_t len,
                           Error* bound_error,
                           TrailPtr bound_trail,
                           Heap::Space space) const {
-    return TypeTest(kIsMoreSpecificThan, other, from_index, len,
-                    bound_error, bound_trail, space);
+    return TypeTest(kIsMoreSpecificThan, other, from_index, len, bound_error,
+                    bound_trail, space);
   }
 
   // Check if the vectors are equal (they may be null).
   bool Equals(const TypeArguments& other) const {
     return IsSubvectorEquivalent(other, 0, IsNull() ? 0 : Length());
   }
 
   bool IsEquivalent(const TypeArguments& other, TrailPtr trail = NULL) const {
     return IsSubvectorEquivalent(other, 0, IsNull() ? 0 : Length(), trail);
   }
@@ skipping 21 matching lines @@
   // Return true if this vector contains a recursive type argument.
   bool IsRecursive() const;
 
   // Clone this type argument vector and clone all unfinalized type arguments.
   // Finalized type arguments are shared.
   RawTypeArguments* CloneUnfinalized() const;
 
   // Clone this type argument vector and clone all uninstantiated type
   // arguments, changing the class owner of type parameters.
   // Instantiated type arguments are shared.
-  RawTypeArguments* CloneUninstantiated(
-      const Class& new_owner, TrailPtr trail = NULL) const;
+  RawTypeArguments* CloneUninstantiated(const Class& new_owner,
+                                        TrailPtr trail = NULL) const;
 
   // Canonicalize only if instantiated, otherwise returns 'this'.
   RawTypeArguments* Canonicalize(TrailPtr trail = NULL) const;
 
   // Returns a formatted list of occuring type arguments with their URI.
   RawString* EnumerateURIs() const;
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
@@ skipping 30 matching lines @@
            OFFSET_OF_RETURNED_VALUE(RawTypeArguments, types));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     // Ensure that the types() is not adding to the object size, which includes
     // 3 fields: instantiations_, length_ and hash_.
     ASSERT(sizeof(RawTypeArguments) ==
            (sizeof(RawObject) + (kNumFields * kWordSize)));
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(
-        sizeof(RawTypeArguments) + (len * kBytesPerElement));
+    return RoundedAllocationSize(sizeof(RawTypeArguments) +
+                                 (len * kBytesPerElement));
   }
 
   intptr_t Hash() const;
 
   static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld);
 
  private:
   intptr_t ComputeHash() const;
   void SetHash(intptr_t value) const;
 
@@ skipping 44 matching lines @@
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
   static bool IsInFullSnapshot(RawPatchClass* cls) {
     NoSafepointScope no_safepoint;
     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
   }
 
   static RawPatchClass* New(const Class& patched_class,
                             const Class& origin_class);
 
-  static RawPatchClass* New(const Class& patched_class,
-                            const Script& source);
+  static RawPatchClass* New(const Class& patched_class, const Script& source);
 
  private:
   void set_patched_class(const Class& value) const;
   void set_origin_class(const Class& value) const;
   void set_script(const Script& value) const;
 
   static RawPatchClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
   friend class Class;
 };
 
 
 class SingleTargetCache : public Object {
  public:
   RawCode* target() const { return raw_ptr()->target_; }
   void set_target(const Code& target) const;
   static intptr_t target_offset() {
     return OFFSET_OF(RawSingleTargetCache, target_);
   }
 
 #define DEFINE_NON_POINTER_FIELD_ACCESSORS(type, name)                         \
   type name() const { return raw_ptr()->name##_; }                             \
   void set_##name(type value) const {                                          \
     StoreNonPointer(&raw_ptr()->name##_, value);                               \
   }                                                                            \
   static intptr_t name##_offset() {                                            \
     return OFFSET_OF(RawSingleTargetCache, name##_);                           \
-  }                                                                            \
+  }
 
-DEFINE_NON_POINTER_FIELD_ACCESSORS(uword, entry_point);
-DEFINE_NON_POINTER_FIELD_ACCESSORS(intptr_t, lower_limit);
-DEFINE_NON_POINTER_FIELD_ACCESSORS(intptr_t, upper_limit);
+  DEFINE_NON_POINTER_FIELD_ACCESSORS(uword, entry_point);
+  DEFINE_NON_POINTER_FIELD_ACCESSORS(intptr_t, lower_limit);
+  DEFINE_NON_POINTER_FIELD_ACCESSORS(intptr_t, upper_limit);
 #undef DEFINE_NON_POINTER_FIELD_ACCESSORS
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSingleTargetCache));
   }
 
   static RawSingleTargetCache* New();
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SingleTargetCache, Object);
@@ skipping 26 matching lines @@
 // copy the ICData in a child object, thus freezing it during background
 // compilation. Code may contain only original ICData objects.
 class ICData : public Object {
  public:
   RawFunction* Owner() const;
 
   RawICData* Original() const;
 
   void SetOriginal(const ICData& value) const;
 
-  bool IsOriginal() const {
-    return Original() == this->raw();
-  }
+  bool IsOriginal() const { return Original() == this->raw(); }
 
-  RawString* target_name() const {
-    return raw_ptr()->target_name_;
-  }
+  RawString* target_name() const { return raw_ptr()->target_name_; }
 
-  RawArray* arguments_descriptor() const {
-    return raw_ptr()->args_descriptor_;
-  }
+  RawArray* arguments_descriptor() const { return raw_ptr()->args_descriptor_; }
 
   intptr_t NumArgsTested() const;
 
   intptr_t deopt_id() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return -1;
 #else
     return raw_ptr()->deopt_id_;
 #endif
   }
 
   bool IsImmutable() const;
 
   void Reset(Zone* zone) const;
   void ResetSwitchable(Zone* zone) const;
 
-  // Note: only deopts with reasons before Unknown in this list are recorded in
-  // the ICData. All other reasons are used purely for informational messages
-  // printed during deoptimization itself.
-  #define DEOPT_REASONS(V)                                                     \
-    V(BinarySmiOp)                                                             \
-    V(BinaryMintOp)                                                            \
-    V(DoubleToSmi)                                                             \
-    V(CheckSmi)                                                                \
-    V(Unknown)                                                                 \
-    V(PolymorphicInstanceCallTestFail)                                         \
-    V(UnaryMintOp)                                                             \
-    V(BinaryDoubleOp)                                                          \
-    V(UnaryOp)                                                                 \
-    V(UnboxInteger)                                                            \
-    V(CheckClass)                                                              \
-    V(CheckArrayBound)                                                         \
-    V(AtCall)                                                                  \
-    V(GuardField)                                                              \
-    V(TestCids)                                                                \
-    V(NumReasons)                                                              \
+// Note: only deopts with reasons before Unknown in this list are recorded in
+// the ICData. All other reasons are used purely for informational messages
+// printed during deoptimization itself.
+#define DEOPT_REASONS(V)                                                       \
+  V(BinarySmiOp)                                                               \
+  V(BinaryMintOp)                                                              \
+  V(DoubleToSmi)                                                               \
+  V(CheckSmi)                                                                  \
+  V(Unknown)                                                                   \
+  V(PolymorphicInstanceCallTestFail)                                           \
+  V(UnaryMintOp)                                                               \
+  V(BinaryDoubleOp)                                                            \
+  V(UnaryOp)                                                                   \
+  V(UnboxInteger)                                                              \
+  V(CheckClass)                                                                \
+  V(CheckArrayBound)                                                           \
+  V(AtCall)                                                                    \
+  V(GuardField)                                                                \
+  V(TestCids)                                                                  \
+  V(NumReasons)
 
   enum DeoptReasonId {
-  #define DEFINE_ENUM_LIST(name) kDeopt##name,
-  DEOPT_REASONS(DEFINE_ENUM_LIST)
-  #undef DEFINE_ENUM_LIST
+#define DEFINE_ENUM_LIST(name) kDeopt##name,
+    DEOPT_REASONS(DEFINE_ENUM_LIST)
+#undef DEFINE_ENUM_LIST
   };
 
   static const intptr_t kLastRecordedDeoptReason = kDeoptUnknown - 1;
 
   enum DeoptFlags {
     // Deoptimization is caused by an optimistically hoisted instruction.
     kHoisted = 1 << 0,
 
     // Deoptimization is caused by an optimistically generalized bounds check.
     kGeneralized = 1 << 1
@@ skipping 20 matching lines @@
   }
 
   static intptr_t target_name_offset() {
     return OFFSET_OF(RawICData, target_name_);
   }
 
   static intptr_t state_bits_offset() {
     return OFFSET_OF(RawICData, state_bits_);
   }
 
-  static intptr_t NumArgsTestedShift() {
-    return kNumArgsTestedPos;
-  }
+  static intptr_t NumArgsTestedShift() { return kNumArgsTestedPos; }
 
   static intptr_t NumArgsTestedMask() {
     return ((1 << kNumArgsTestedSize) - 1) << kNumArgsTestedPos;
   }
 
   static intptr_t arguments_descriptor_offset() {
     return OFFSET_OF(RawICData, args_descriptor_);
   }
 
-  static intptr_t ic_data_offset() {
-    return OFFSET_OF(RawICData, ic_data_);
-  }
+  static intptr_t ic_data_offset() { return OFFSET_OF(RawICData, ic_data_); }
 
-  static intptr_t owner_offset() {
-    return OFFSET_OF(RawICData, owner_);
-  }
+  static intptr_t owner_offset() { return OFFSET_OF(RawICData, owner_); }
 
   // Replaces entry |index| with the sentinel.
   void WriteSentinelAt(intptr_t index) const;
 
   // Clears the count for entry |index|.
   void ClearCountAt(intptr_t index) const;
 
   // Clear all entries with the sentinel value (but will preserve initial
   // smi smi checks).
   void ClearWithSentinel() const;
@@ skipping 58 matching lines @@
   intptr_t GetCountAt(intptr_t index) const;
   intptr_t AggregateCount() const;
 
   // Returns this->raw() if num_args_tested == 1 and arg_nr == 1, otherwise
   // returns a new ICData object containing only unique arg_nr checks.
   // Returns only used entries.
   RawICData* AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
   RawICData* AsUnaryClassChecks() const {
     return AsUnaryClassChecksForArgNr(0);
   }
-  RawICData* AsUnaryClassChecksForCid(
-      intptr_t cid, const Function& target) const;
+  RawICData* AsUnaryClassChecksForCid(intptr_t cid,
+                                      const Function& target) const;
 
   // Returns ICData with aggregated receiver count, sorted by highest count.
   // Smi not first!! (the convention for ICData used in code generation is that
   // Smi check is first)
   // Used for printing and optimizations.
   RawICData* AsUnaryClassChecksSortedByCount() const;
 
   // Consider only used entries.
   bool AllTargetsHaveSameOwner(intptr_t owner_cid) const;
   bool AllReceiversAreNumbers() const;
   bool HasOneTarget() const;
   bool HasOnlyDispatcherTargets() const;
   bool HasReceiverClassId(intptr_t class_id) const;
 
   static RawICData* 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);
   static RawICData* NewFrom(const ICData& from, intptr_t num_args_tested);
 
   // Generates a new ICData with descriptor and data array copied (deep clone).
   static RawICData* Clone(const ICData& from);
 
   static intptr_t TestEntryLengthFor(intptr_t num_args);
 
-  static intptr_t TargetIndexFor(intptr_t num_args) {
-    return num_args;
-  }
-  static intptr_t CodeIndexFor(intptr_t num_args) {
-    return num_args;
-  }
+  static intptr_t TargetIndexFor(intptr_t num_args) { return num_args; }
+  static intptr_t CodeIndexFor(intptr_t num_args) { return num_args; }
 
-  static intptr_t CountIndexFor(intptr_t num_args) {
-    return (num_args + 1);
-  }
+  static intptr_t CountIndexFor(intptr_t num_args) { return (num_args + 1); }
   static intptr_t EntryPointIndexFor(intptr_t num_args) {
     return (num_args + 1);
   }
 
   bool IsUsedAt(intptr_t i) const;
 
   void GetUsedCidsForTwoArgs(GrowableArray<intptr_t>* first,
                              GrowableArray<intptr_t>* second) const;
 
   void PrintToJSONArray(const JSONArray& jsarray,
                         TokenPosition token_pos) const;
 
   // Initialize the preallocated empty ICData entry arrays.
   static void InitOnce();
 
-  enum {
-    kCachedICDataArrayCount = 4
-  };
+  enum { kCachedICDataArrayCount = 4 };
 
 #if defined(TAG_IC_DATA)
   void set_tag(intptr_t value) const;
   intptr_t tag() const { return raw_ptr()->tag_; }
 #endif
 
   void SetIsStaticCall(bool static_call) const;
   bool is_static_call() const;
 
  private:
   static RawICData* New();
 
-  RawArray* ic_data() const {
-    return raw_ptr()->ic_data_;
-  }
+  RawArray* ic_data() const { return raw_ptr()->ic_data_; }
 
   void set_owner(const Function& value) const;
   void set_target_name(const String& value) const;
   void set_arguments_descriptor(const Array& value) const;
   void set_deopt_id(intptr_t value) const;
   void SetNumArgsTested(intptr_t value) const;
   void set_ic_data_array(const Array& value) const;
   void set_state_bits(uint32_t bits) const;
 
   bool ValidateInterceptor(const Function& target) const;
@@ skipping 82 matching lines @@
   }
 
   // Build a string of the form '(T, {B b, C c}) => R' representing the
   // user visible signature of the given function. In this example, T and R are
   // type parameters of class C, the owner of the function, also called the
   // scope class of the function type.
   // Implicit parameters are hidden, as well as the prefix denoting the
   // scope class and its type parameters.
   RawString* UserVisibleSignature() const {
     const bool instantiate = false;
-    return BuildSignature(
-        instantiate, kUserVisibleName, TypeArguments::Handle());
+    return BuildSignature(instantiate, kUserVisibleName,
+                          TypeArguments::Handle());
   }
 
   // Build a string of the form '(A, {B b, C c}) => D' representing the
   // signature of the given function, where all generic types (e.g. '<T, R>' in
   // 'C<T, R>(T, {B b, C c}) => R') are instantiated using the given
   // instantiator type argument vector of a C instance (e.g. '<A, D>').
   RawString* InstantiatedSignatureFrom(const TypeArguments& instantiator,
                                        NameVisibility name_visibility) const {
     const bool instantiate = true;
     return BuildSignature(instantiate, name_visibility, instantiator);
@@ skipping 35 matching lines @@
   // Parameter names are valid for all valid parameter indices, and are not
   // limited to named optional parameters.
   RawString* ParameterNameAt(intptr_t index) const;
   void SetParameterNameAt(intptr_t index, const String& value) const;
   RawArray* parameter_names() const { return raw_ptr()->parameter_names_; }
   void set_parameter_names(const Array& value) const;
 
   // The type parameters (and their bounds) are specified as an array of
   // TypeParameter.
   RawTypeArguments* type_parameters() const {
-      return raw_ptr()->type_parameters_;
+    return raw_ptr()->type_parameters_;
   }
   void set_type_parameters(const TypeArguments& value) const;
   intptr_t NumTypeParameters(Thread* thread) const;
 
   // Return a TypeParameter if the type_name is a type parameter of this
   // function or of one of its parent functions.
   // Unless NULL, adjust function_level accordingly (in and out parameter).
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name,
                                         intptr_t* function_level) const;
@@ skipping 13 matching lines @@
 
   // Disables optimized code and switches to unoptimized code (or the lazy
   // compilation stub).
   void SwitchToLazyCompiledUnoptimizedCode() const;
 
   // Compiles unoptimized code (if necessary) and attaches it to the function.
   void EnsureHasCompiledUnoptimizedCode() const;
 
   // Return the most recently compiled and installed code for this function.
   // It is not the only Code object that points to this function.
-  RawCode* CurrentCode() const {
-    return raw_ptr()->code_;
-  }
+  RawCode* CurrentCode() const { return raw_ptr()->code_; }
 
   RawCode* unoptimized_code() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     return static_cast<RawCode*>(Object::null());
 #else
     return raw_ptr()->unoptimized_code_;
 #endif
   }
   void set_unoptimized_code(const Code& value) const;
   bool HasCode() const;
 
-  static intptr_t code_offset() {
-    return OFFSET_OF(RawFunction, code_);
-  }
+  static intptr_t code_offset() { return OFFSET_OF(RawFunction, code_); }
 
   static intptr_t entry_point_offset() {
     return OFFSET_OF(RawFunction, entry_point_);
   }
 
   virtual intptr_t Hash() const;
 
   // Returns true if there is at least one debugger breakpoint
   // set in this function.
   bool HasBreakpoint() const;
@@ skipping 122 matching lines @@
 #endif
   }
   void set_token_pos(TokenPosition value) const;
 
   TokenPosition end_token_pos() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     return TokenPosition();
 #else
     return raw_ptr()->end_token_pos_;
 #endif
-}
+  }
   void set_end_token_pos(TokenPosition value) const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
 #else
     StoreNonPointer(&raw_ptr()->end_token_pos_, value);
 #endif
   }
 
   intptr_t num_fixed_parameters() const {
     return raw_ptr()->num_fixed_parameters_;
@@ skipping 173 matching lines @@
   bool HasCompatibleParametersWith(const Function& other,
                                    Error* bound_error) const;
 
   // Returns true if the type of this function is a subtype of the type of
   // the other function.
   bool IsSubtypeOf(const TypeArguments& type_arguments,
                    const Function& other,
                    const TypeArguments& other_type_arguments,
                    Error* bound_error,
                    Heap::Space space) const {
-    return TypeTest(kIsSubtypeOf,
-                    type_arguments,
-                    other,
-                    other_type_arguments,
-                    bound_error,
-                    space);
+    return TypeTest(kIsSubtypeOf, type_arguments, other, other_type_arguments,
+                    bound_error, space);
   }
 
   // Returns true if the type of this function is more specific than the type of
   // the other function.
   bool IsMoreSpecificThan(const TypeArguments& type_arguments,
                           const Function& other,
                           const TypeArguments& other_type_arguments,
                           Error* bound_error,
                           Heap::Space space) const {
-    return TypeTest(kIsMoreSpecificThan,
-                    type_arguments,
-                    other,
-                    other_type_arguments,
-                    bound_error,
-                    space);
+    return TypeTest(kIsMoreSpecificThan, type_arguments, other,
+                    other_type_arguments, bound_error, space);
   }
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const TypeArguments& type_arguments,
                 const Function& other,
                 const TypeArguments& other_type_arguments,
                 Error* bound_error,
                 Heap::Space space) const;
 
@@ skipping 45 matching lines @@
 
   // Returns true if this function represents an implicit instance closure
   // function.
   bool IsImplicitInstanceClosureFunction() const {
     return !is_static() && IsImplicitClosureFunction();
   }
 
   bool IsConstructorClosureFunction() const;
 
   // Returns true if this function represents a local function.
-  bool IsLocalFunction() const {
-    return parent_function() != Function::null();
-  }
+  bool IsLocalFunction() const { return parent_function() != Function::null(); }
 
   // Returns true if this function represents a signature function without code.
   bool IsSignatureFunction() const {
     return kind() == RawFunction::kSignatureFunction;
   }
   static bool IsSignatureFunction(RawFunction* function) {
     NoSafepointScope no_safepoint;
     return KindBits::decode(function->ptr()->kind_tag_) ==
-        RawFunction::kSignatureFunction;
+           RawFunction::kSignatureFunction;
   }
 
-  bool IsAsyncFunction() const {
-    return modifier() == RawFunction::kAsync;
-  }
+  bool IsAsyncFunction() const { return modifier() == RawFunction::kAsync; }
 
   bool IsAsyncClosure() const {
     return is_generated_body() &&
-        Function::Handle(parent_function()).IsAsyncFunction();
+           Function::Handle(parent_function()).IsAsyncFunction();
   }
 
   bool IsGenerator() const {
     return (modifier() & RawFunction::kGeneratorBit) != 0;
   }
 
-  bool IsSyncGenerator() const {
-    return modifier() == RawFunction::kSyncGen;
-  }
+  bool IsSyncGenerator() const { return modifier() == RawFunction::kSyncGen; }
 
   bool IsSyncGenClosure() const {
     return is_generated_body() &&
-        Function::Handle(parent_function()).IsSyncGenerator();
+           Function::Handle(parent_function()).IsSyncGenerator();
   }
 
   bool IsGeneratorClosure() const {
     return is_generated_body() &&
-        Function::Handle(parent_function()).IsGenerator();
+           Function::Handle(parent_function()).IsGenerator();
   }
 
-  bool IsAsyncGenerator() const {
-    return modifier() == RawFunction::kAsyncGen;
-  }
+  bool IsAsyncGenerator() const { return modifier() == RawFunction::kAsyncGen; }
 
   bool IsAsyncGenClosure() const {
     return is_generated_body() &&
-        Function::Handle(parent_function()).IsAsyncGenerator();
+           Function::Handle(parent_function()).IsAsyncGenerator();
   }
 
   bool IsAsyncOrGenerator() const {
     return modifier() != RawFunction::kNoModifier;
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunction));
   }
 
@@ skipping 64 matching lines @@
   }
   bool was_compiled() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return true;
 #else
     return raw_ptr()->was_compiled_ == 1;
 #endif
   }
 
-  // static: Considered during class-side or top-level resolution rather than
-  //         instance-side resolution.
-  // const: Valid target of a const constructor call.
-  // abstract: Skipped during instance-side resolution.
-  // reflectable: Enumerated by mirrors, invocable by mirrors. False for private
-  //              functions of dart: libraries.
-  // debuggable: Valid location of a breakpoint. Synthetic code is not
-  //             debuggable.
-  // visible: Frame is included in stack traces. Synthetic code such as
-  //          dispatchers is not visible. Synthetic code that can trigger
-  //          exceptions such as the outer async functions that create Futures
-  //          is visible.
-  // optimizable: Candidate for going through the optimizing compiler. False for
-  //              some functions known to be execute infrequently and functions
-  //              which have been de-optimized too many times.
-  // instrinsic: Has a hand-written assembly prologue.
-  // inlinable: Candidate for inlining. False for functions with features we
-  //            don't support during inlining (e.g., optional parameters),
-  //            functions which are too big, etc.
-  // native: Bridge to C/C++ code.
-  // redirecting: Redirecting generative or factory constructor.
-  // external: Just a declaration that expects to be defined in another patch
-  //           file.
+// static: Considered during class-side or top-level resolution rather than
+//         instance-side resolution.
+// const: Valid target of a const constructor call.
+// abstract: Skipped during instance-side resolution.
+// reflectable: Enumerated by mirrors, invocable by mirrors. False for private
+//              functions of dart: libraries.
+// debuggable: Valid location of a breakpoint. Synthetic code is not
+//             debuggable.
+// visible: Frame is included in stack traces. Synthetic code such as
+//          dispatchers is not visible. Synthetic code that can trigger
+//          exceptions such as the outer async functions that create Futures
+//          is visible.
+// optimizable: Candidate for going through the optimizing compiler. False for
+//              some functions known to be execute infrequently and functions
+//              which have been de-optimized too many times.
+// instrinsic: Has a hand-written assembly prologue.
+// inlinable: Candidate for inlining. False for functions with features we
+//            don't support during inlining (e.g., optional parameters),
+//            functions which are too big, etc.
+// native: Bridge to C/C++ code.
+// redirecting: Redirecting generative or factory constructor.
+// external: Just a declaration that expects to be defined in another patch
+//           file.
 
 #define FOR_EACH_FUNCTION_KIND_BIT(V)                                          \
   V(Static, is_static)                                                         \
   V(Const, is_const)                                                           \
   V(Abstract, is_abstract)                                                     \
   V(Reflectable, is_reflectable)                                               \
   V(Visible, is_visible)                                                       \
   V(Debuggable, is_debuggable)                                                 \
   V(Optimizable, is_optimizable)                                               \
   V(Inlinable, is_inlinable)                                                   \
   V(Intrinsic, is_intrinsic)                                                   \
   V(Native, is_native)                                                         \
   V(Redirecting, is_redirecting)                                               \
   V(External, is_external)                                                     \
   V(AllowsHoistingCheckClass, allows_hoisting_check_class)                     \
   V(AllowsBoundsCheckGeneralization, allows_bounds_check_generalization)       \
   V(GeneratedBody, is_generated_body)                                          \
   V(AlwaysInline, always_inline)                                               \
-  V(PolymorphicTarget, is_polymorphic_target)                                  \
+  V(PolymorphicTarget, is_polymorphic_target)
 
 #define DEFINE_ACCESSORS(name, accessor_name)                                  \
   void set_##accessor_name(bool value) const {                                 \
     set_kind_tag(name##Bit::update(value, raw_ptr()->kind_tag_));              \
   }                                                                            \
-  bool accessor_name() const {                                                 \
-    return name##Bit::decode(raw_ptr()->kind_tag_);                            \
-  }
-FOR_EACH_FUNCTION_KIND_BIT(DEFINE_ACCESSORS)
+  bool accessor_name() const { return name##Bit::decode(raw_ptr()->kind_tag_); }
+  FOR_EACH_FUNCTION_KIND_BIT(DEFINE_ACCESSORS)
 #undef DEFINE_ACCESSORS
 
  private:
   void set_ic_data_array(const Array& value) const;
   void SetInstructionsSafe(const Code& value) const;
 
   enum KindTagBits {
     kKindTagPos = 0,
     kKindTagSize = 4,
     kRecognizedTagPos = kKindTagPos + kKindTagSize,
     kRecognizedTagSize = 9,
     kModifierPos = kRecognizedTagPos + kRecognizedTagSize,
     kModifierSize = 2,
     kLastModifierBitPos = kModifierPos + (kModifierSize - 1),
-    // Single bit sized fields start here.
+// Single bit sized fields start here.
 #define DECLARE_BIT(name, _) k##name##Bit,
-FOR_EACH_FUNCTION_KIND_BIT(DECLARE_BIT)
+    FOR_EACH_FUNCTION_KIND_BIT(DECLARE_BIT)
 #undef DECLARE_BIT
-    kNumTagBits
+        kNumTagBits
   };
 
-  COMPILE_ASSERT(
-      MethodRecognizer::kNumRecognizedMethods < (1 << kRecognizedTagSize));
-  COMPILE_ASSERT(
-      kNumTagBits <=
-      (kBitsPerByte * sizeof(static_cast<RawFunction*>(0)->kind_tag_)));
+  COMPILE_ASSERT(MethodRecognizer::kNumRecognizedMethods <
+                 (1 << kRecognizedTagSize));
+  COMPILE_ASSERT(kNumTagBits <=
+                 (kBitsPerByte *
+                  sizeof(static_cast<RawFunction*>(0)->kind_tag_)));
 
-  class KindBits :
-    public BitField<uint32_t, RawFunction::Kind, kKindTagPos, kKindTagSize> {};
+  class KindBits : public BitField<uint32_t,
+                                   RawFunction::Kind,
+                                   kKindTagPos,
+                                   kKindTagSize> {};
 
   class RecognizedBits : public BitField<uint32_t,
                                          MethodRecognizer::Kind,
                                          kRecognizedTagPos,
                                          kRecognizedTagSize> {};
   class ModifierBits : public BitField<uint32_t,
                                        RawFunction::AsyncModifier,
                                        kModifierPos,
                                        kModifierSize> {};
 
-#define DEFINE_BIT(name, _) \
+#define DEFINE_BIT(name, _)                                                    \
   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
-FOR_EACH_FUNCTION_KIND_BIT(DEFINE_BIT)
+  FOR_EACH_FUNCTION_KIND_BIT(DEFINE_BIT)
 #undef DEFINE_BIT
 
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
   RawFunction* implicit_closure_function() const;
   void set_implicit_closure_function(const Function& value) const;
   RawInstance* implicit_static_closure() const;
   void set_implicit_static_closure(const Instance& closure) const;
@@ skipping 33 matching lines @@
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
   friend class SnapshotWriter;
   friend class Parser;  // For set_eval_script.
   // RawFunction::VisitFunctionPointers accesses the private constructor of
   // Function.
   friend class RawFunction;
 };
 
 
-class ClosureData: public Object {
+class ClosureData : public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClosureData));
   }
 
  private:
   RawContextScope* context_scope() const { return raw_ptr()->context_scope_; }
   void set_context_scope(const ContextScope& value) const;
 
   // Enclosing function of this local function.
   RawFunction* parent_function() const { return raw_ptr()->parent_function_; }
   void set_parent_function(const Function& value) const;
 
   // Signature type of this closure function.
   RawType* signature_type() const { return raw_ptr()->signature_type_; }
   void set_signature_type(const Type& value) const;
 
-  RawInstance* implicit_static_closure() const {
-    return raw_ptr()->closure_;
-  }
+  RawInstance* implicit_static_closure() const { return raw_ptr()->closure_; }
   void set_implicit_static_closure(const Instance& closure) const;
 
   static RawClosureData* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ClosureData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
 
-class RedirectionData: public Object {
+class RedirectionData : public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawRedirectionData));
   }
 
  private:
   // The type specifies the class and type arguments of the target constructor.
   RawType* type() const { return raw_ptr()->type_; }
   void set_type(const Type& value) const;
 
@@ skipping 77 matching lines @@
 
   inline RawInstance* StaticValue() const;
   inline void SetStaticValue(const Instance& value,
                              bool save_initial_value = false) const;
 
   RawClass* Owner() const;
   RawClass* Origin() const;  // Either mixin class, or same as owner().
   RawScript* Script() const;
   RawObject* RawOwner() const;
 
-  RawAbstractType* type() const  { return raw_ptr()->type_; }
+  RawAbstractType* type() const { return raw_ptr()->type_; }
   // Used by class finalizer, otherwise initialized in constructor.
   void SetFieldType(const AbstractType& value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawField));
   }
 
   static RawField* New(const String& name,
                        bool is_static,
                        bool is_final,
@@ skipping 27 matching lines @@
 
   TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
 
   bool has_initializer() const {
     return HasInitializerBit::decode(raw_ptr()->kind_bits_);
   }
   // Called by parser after allocating field.
   void set_has_initializer(bool has_initializer) const {
     ASSERT(IsOriginal());
     ASSERT(Thread::Current()->IsMutatorThread());
-    set_kind_bits(HasInitializerBit::update(has_initializer,
-                                            raw_ptr()->kind_bits_));
+    set_kind_bits(
+        HasInitializerBit::update(has_initializer, raw_ptr()->kind_bits_));
   }
 
   // Return class id that any non-null value read from this field is guaranteed
   // to have or kDynamicCid if such class id is not known.
   // Stores to this field must update this information hence the name.
   intptr_t guarded_cid() const {
 #if defined(DEGUG)
     Thread* thread = Thread::Current();
     ASSERT(!IsOriginal() || thread->IsMutator() || thread->IsAtSafepoint());
 #endif
@@ skipping 26 matching lines @@
   }
 
   bool needs_length_check() const {
     const bool r = guarded_list_length() >= Field::kUnknownFixedLength;
     ASSERT(!r || is_final());
     return r;
   }
 
   const char* GuardedPropertiesAsCString() const;
 
-  intptr_t UnboxedFieldCid() const {
-    return guarded_cid();
-  }
+  intptr_t UnboxedFieldCid() const { return guarded_cid(); }
 
   bool is_unboxing_candidate() const {
     return UnboxingCandidateBit::decode(raw_ptr()->kind_bits_);
   }
   // Default 'true', set to false once optimizing compiler determines it should
   // be boxed.
   void set_is_unboxing_candidate(bool b) const {
     ASSERT(IsOriginal());
     set_kind_bits(UnboxingCandidateBit::update(b, raw_ptr()->kind_bits_));
   }
 
   static bool IsExternalizableCid(intptr_t cid);
 
   enum {
     kUnknownLengthOffset = -1,
     kUnknownFixedLength = -1,
     kNoFixedLength = -2,
   };
   // Returns false if any value read from this field is guaranteed to be
   // not null.
   // Internally we is_nullable_ field contains either kNullCid (nullable) or
   // any other value (non-nullable) instead of boolean. This is done to simplify
   // guarding sequence in the generated code.
-  bool is_nullable() const {
-    return raw_ptr()->is_nullable_ == kNullCid;
-  }
+  bool is_nullable() const { return raw_ptr()->is_nullable_ == kNullCid; }
   void set_is_nullable(bool val) const {
     ASSERT(Thread::Current()->IsMutatorThread());
     StoreNonPointer(&raw_ptr()->is_nullable_, val ? kNullCid : kIllegalCid);
   }
   static intptr_t is_nullable_offset() {
     return OFFSET_OF(RawField, is_nullable_);
   }
 
   // Record store of the given value into this field. May trigger
   // deoptimization of dependent optimized code.
@@ skipping 69 matching lines @@
     kStaticBit,
     kFinalBit,
     kHasInitializerBit,
     kUnboxingCandidateBit,
     kReflectableBit,
     kDoubleInitializedBit,
   };
   class ConstBit : public BitField<uint8_t, bool, kConstBit, 1> {};
   class StaticBit : public BitField<uint8_t, bool, kStaticBit, 1> {};
   class FinalBit : public BitField<uint8_t, bool, kFinalBit, 1> {};
-  class HasInitializerBit :
-      public BitField<uint8_t, bool, kHasInitializerBit, 1> {};
-  class UnboxingCandidateBit :
-      public BitField<uint8_t, bool, kUnboxingCandidateBit, 1> {};
+  class HasInitializerBit
+      : public BitField<uint8_t, bool, kHasInitializerBit, 1> {};
+  class UnboxingCandidateBit
+      : public BitField<uint8_t, bool, kUnboxingCandidateBit, 1> {};
   class ReflectableBit : public BitField<uint8_t, bool, kReflectableBit, 1> {};
-  class DoubleInitializedBit :
-      public BitField<uint8_t, bool, kDoubleInitializedBit, 1> {};
+  class DoubleInitializedBit
+      : public BitField<uint8_t, bool, kDoubleInitializedBit, 1> {};
 
   // Update guarded cid and guarded length for this field. Returns true, if
   // deoptimization of dependent code is required.
   bool UpdateGuardedCidAndLength(const Object& value) const;
 
   // Force this field's guard to be dynamic and deoptimize dependent code.
   void ForceDynamicGuardedCidAndLength() const;
 
   void set_name(const String& value) const;
   void set_is_static(bool is_static) const {
@@ skipping 52 matching lines @@
 
 class TokenStream : public Object {
  public:
   RawGrowableObjectArray* TokenObjects() const;
   void SetTokenObjects(const GrowableObjectArray& value) const;
 
   RawExternalTypedData* GetStream() const;
   void SetStream(const ExternalTypedData& stream) const;
 
   RawString* GenerateSource() const;
-  RawString* GenerateSource(TokenPosition start,
-                            TokenPosition end) const;
+  RawString* GenerateSource(TokenPosition start, TokenPosition end) const;
   intptr_t ComputeSourcePosition(TokenPosition tok_pos) const;
 
   RawString* PrivateKey() const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTokenStream));
   }
 
   static RawTokenStream* New(intptr_t length);
   static RawTokenStream* New(const String& source,
                              const String& private_key,
                              bool use_shared_tokens);
 
   static void OpenSharedTokenList(Isolate* isolate);
   static void CloseSharedTokenList(Isolate* isolate);
 
   // The class Iterator encapsulates iteration over the tokens
   // in a TokenStream object.
   class Iterator : ValueObject {
    public:
-    enum StreamType {
-      kNoNewlines,
-      kAllTokens
-    };
+    enum StreamType { kNoNewlines, kAllTokens };
 
     Iterator(Zone* zone,
              const TokenStream& tokens,
              TokenPosition token_pos,
              Iterator::StreamType stream_type = kNoNewlines);
 
     void SetStream(const TokenStream& tokens, TokenPosition token_pos);
     bool IsValid() const;
 
-    inline Token::Kind CurrentTokenKind() const {
-      return cur_token_kind_;
-    }
+    inline Token::Kind CurrentTokenKind() const { return cur_token_kind_; }
 
     Token::Kind LookaheadTokenKind(intptr_t num_tokens);
 
     TokenPosition CurrentPosition() const;
     void SetCurrentPosition(TokenPosition token_pos);
 
     void Advance();
 
     RawObject* CurrentToken() const;
     RawString* CurrentLiteral() const;
@@ skipping 18 matching lines @@
     intptr_t cur_token_obj_index_;
     Iterator::StreamType stream_type_;
   };
 
  private:
   void SetPrivateKey(const String& value) const;
 
   static RawTokenStream* New();
   static void DataFinalizer(void* isolate_callback_data,
                             Dart_WeakPersistentHandle handle,
-                            void *peer);
+                            void* peer);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
 
 class Script : public Object {
  public:
   RawString* url() const { return raw_ptr()->url_; }
 
@@ skipping 13 matching lines @@
   // The load time in milliseconds since epoch.
   int64_t load_timestamp() const { return raw_ptr()->load_timestamp_; }
 
   RawArray* compile_time_constants() const {
     return raw_ptr()->compile_time_constants_;
   }
   void set_compile_time_constants(const Array& value) const;
 
   RawTokenStream* tokens() const { return raw_ptr()->tokens_; }
 
-  void Tokenize(const String& private_key,
-                bool use_shared_tokens = true) const;
+  void Tokenize(const String& private_key, bool use_shared_tokens = true) const;
 
   RawLibrary* FindLibrary() const;
   RawString* GetLine(intptr_t line_number,
                      Heap::Space space = Heap::kNew) const;
   RawString* GetSnippet(intptr_t from_line,
                         intptr_t from_column,
                         intptr_t to_line,
                         intptr_t to_column) const;
 
   void SetLocationOffset(intptr_t line_offset, intptr_t col_offset) const;
@@ skipping 47 matching lines @@
   bool HasNext() const { return next_ix_ < size_; }
 
   // Returns next non-null raw object.
   RawObject* GetNext();
 
  private:
   void MoveToNextObject();
 
   const Array& array_;
   const int size_;  // Number of elements to iterate over.
-  int next_ix_;  // Index of next element.
+  int next_ix_;     // Index of next element.
 
   friend class ClassDictionaryIterator;
   friend class LibraryPrefixIterator;
   DISALLOW_COPY_AND_ASSIGN(DictionaryIterator);
 };
 
 
 class ClassDictionaryIterator : public DictionaryIterator {
  public:
   enum IterationKind {
     // TODO(hausner): fix call sites that use kIteratePrivate. There is only
     // one top-level class per library left, not an array to iterate over.
     kIteratePrivate,
     kNoIteratePrivate
   };
 
   ClassDictionaryIterator(const Library& library,
                           IterationKind kind = kNoIteratePrivate);
 
   bool HasNext() const {
-      return (next_ix_ < size_) || !toplevel_class_.IsNull();
+    return (next_ix_ < size_) || !toplevel_class_.IsNull();
   }
 
   // Returns a non-null raw class.
   RawClass* GetNextClass();
 
  private:
   void MoveToNextClass();
 
   Class& toplevel_class_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
 };
 
 
 class LibraryPrefixIterator : public DictionaryIterator {
  public:
   explicit LibraryPrefixIterator(const Library& library);
   RawLibraryPrefix* GetNext();
+
  private:
   void Advance();
   DISALLOW_COPY_AND_ASSIGN(LibraryPrefixIterator);
 };
 
 
 class Library : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   void SetName(const String& name) const;
@@ skipping 75 matching lines @@
   RawObject* ResolveName(const String& name) const;
 
   void AddAnonymousClass(const Class& cls) const;
 
   void AddExport(const Namespace& ns) const;
 
   void AddClassMetadata(const Class& cls,
                         const Object& tl_owner,
                         TokenPosition token_pos) const;
   void AddFieldMetadata(const Field& field, TokenPosition token_pos) const;
-  void AddFunctionMetadata(const Function& func,
-                           TokenPosition token_pos) const;
+  void AddFunctionMetadata(const Function& func, TokenPosition token_pos) const;
   void AddLibraryMetadata(const Object& tl_owner,
                           TokenPosition token_pos) const;
   void AddTypeParameterMetadata(const TypeParameter& param,
                                 TokenPosition token_pos) const;
   RawObject* GetMetadata(const Object& obj) const;
 
-  RawClass* toplevel_class() const {
-    return raw_ptr()->toplevel_class_;
-  }
+  RawClass* toplevel_class() const { return raw_ptr()->toplevel_class_; }
   void set_toplevel_class(const Class& value) const;
 
   RawGrowableObjectArray* patch_classes() const {
     return raw_ptr()->patch_classes_;
   }
 
   // Library imports.
   RawArray* imports() const { return raw_ptr()->imports_; }
   RawArray* exports() const { return raw_ptr()->exports_; }
   void AddImport(const Namespace& ns) const;
@@ skipping 31 matching lines @@
 
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const {
     StoreNonPointer(&raw_ptr()->index_, value);
   }
 
   void Register(Thread* thread) const;
   static void RegisterLibraries(Thread* thread,
                                 const GrowableObjectArray& libs);
 
-  bool IsDebuggable() const {
-    return raw_ptr()->debuggable_;
-  }
+  bool IsDebuggable() const { return raw_ptr()->debuggable_; }
   void set_debuggable(bool value) const {
     StoreNonPointer(&raw_ptr()->debuggable_, value);
   }
 
-  bool is_dart_scheme() const {
-    return raw_ptr()->is_dart_scheme_;
-  }
+  bool is_dart_scheme() const { return raw_ptr()->is_dart_scheme_; }
   void set_is_dart_scheme(bool value) const {
     StoreNonPointer(&raw_ptr()->is_dart_scheme_, value);
   }
 
-  bool IsCoreLibrary() const {
-    return raw() == CoreLibrary();
-  }
+  bool IsCoreLibrary() const { return raw() == CoreLibrary(); }
 
   inline intptr_t UrlHash() const;
 
   static RawLibrary* LookupLibrary(Thread* thread, const String& url);
   static RawLibrary* GetLibrary(intptr_t index);
 
   static void InitCoreLibrary(Isolate* isolate);
   static void InitNativeWrappersLibrary(Isolate* isolate);
 
   static RawLibrary* AsyncLibrary();
@@ skipping 27 matching lines @@
   // helper methods and classes. Allow look up of private classes.
   static RawClass* LookupCoreClass(const String& class_name);
 
 
   // Return Function::null() if function does not exist in libs.
   static RawFunction* GetFunction(const GrowableArray<Library*>& libs,
                                   const char* class_name,
                                   const char* function_name);
 
   // Character used to indicate a private identifier.
-  static const char kPrivateIdentifierStart  = '_';
+  static const char kPrivateIdentifierStart = '_';
 
   // Character used to separate private identifiers from
   // the library-specific key.
   static const char kPrivateKeySeparator = '@';
 
   void CheckReload(const Library& replacement,
                    IsolateReloadContext* context) const;
 
  private:
   static const int kInitialImportsCapacity = 4;
@@ skipping 18 matching lines @@
   void InvalidateResolvedName(const String& name) const;
   void InvalidateResolvedNamesCache() const;
 
   RawArray* exported_names() const { return raw_ptr()->exported_names_; }
   bool LookupExportedNamesCache(const String& name, Object* obj) const;
   void AddToExportedNamesCache(const String& name, const Object& obj) const;
 
 
   void InitImportList() const;
   void GrowDictionary(const Array& dict, intptr_t dict_size) const;
-  static RawLibrary* NewLibraryHelper(const String& url,
-                                      bool import_core_lib);
-  RawObject* LookupEntry(const String& name, intptr_t *index) const;
+  static RawLibrary* NewLibraryHelper(const String& url, bool import_core_lib);
+  RawObject* LookupEntry(const String& name, intptr_t* index) const;
 
   void AllocatePrivateKey() const;
 
   RawString* MakeMetadataName(const Object& obj) const;
   RawField* GetMetadataField(const String& metaname) const;
   void AddMetadata(const Object& owner,
                    const String& name,
                    TokenPosition token_pos) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
@@ skipping 48 matching lines @@
 // which is stored in a typed data array (info_array).
 class ObjectPool : public Object {
  public:
   enum EntryType {
     kTaggedObject,
     kImmediate,
     kNativeEntry,
   };
 
   struct Entry {
-    Entry() : raw_value_(), type_() { }
-    explicit Entry(const Object* obj) : obj_(obj), type_(kTaggedObject) { }
-    Entry(uword value, EntryType info) : raw_value_(value), type_(info) { }
+    Entry() : raw_value_(), type_() {}
+    explicit Entry(const Object* obj) : obj_(obj), type_(kTaggedObject) {}
+    Entry(uword value, EntryType info) : raw_value_(value), type_(info) {}
     union {
       const Object* obj_;
       uword raw_value_;
     };
     EntryType type_;
   };
 
-  intptr_t Length() const {
-    return raw_ptr()->length_;
-  }
+  intptr_t Length() const { return raw_ptr()->length_; }
   void SetLength(intptr_t value) const {
     StoreNonPointer(&raw_ptr()->length_, value);
   }
 
-  RawTypedData* info_array() const {
-    return raw_ptr()->info_array_;
-  }
+  RawTypedData* info_array() const { return raw_ptr()->info_array_; }
 
   void set_info_array(const TypedData& info_array) const;
 
   static intptr_t length_offset() { return OFFSET_OF(RawObjectPool, length_); }
   static intptr_t data_offset() {
     return OFFSET_OF_RETURNED_VALUE(RawObjectPool, data);
   }
   static intptr_t element_offset(intptr_t index) {
-    return OFFSET_OF_RETURNED_VALUE(RawObjectPool, data)
-        + kBytesPerElement * index;
+    return OFFSET_OF_RETURNED_VALUE(RawObjectPool, data) +
+           kBytesPerElement * index;
   }
 
   EntryType InfoAt(intptr_t index) const;
 
   RawObject* ObjectAt(intptr_t index) const {
     ASSERT(InfoAt(index) == kTaggedObject);
     return EntryAddr(index)->raw_obj_;
   }
   void SetObjectAt(intptr_t index, const Object& obj) const {
     ASSERT(InfoAt(index) == kTaggedObject);
@@ skipping 15 matching lines @@
     return 0;
   }
 
   static const intptr_t kBytesPerElement = sizeof(RawObjectPool::Entry);
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize(intptr_t len) {
     // Ensure that variable length data is not adding to the object length.
     ASSERT(sizeof(RawObjectPool) == (sizeof(RawObject) + (2 * kWordSize)));
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(
-        sizeof(RawObjectPool) + (len * kBytesPerElement));
+    return RoundedAllocationSize(sizeof(RawObjectPool) +
+                                 (len * kBytesPerElement));
   }
 
   static RawObjectPool* New(intptr_t len);
 
   // Returns the pool index from the offset relative to a tagged RawObjectPool*,
   // adjusting for the tag-bit.
   static intptr_t IndexFromOffset(intptr_t offset) {
     ASSERT(Utils::IsAligned(offset + kHeapObjectTag, kWordSize));
     return (offset + kHeapObjectTag - data_offset()) / kBytesPerElement;
   }
@@ skipping 16 matching lines @@
   friend class RawObjectPool;
 };
 
 
 class Instructions : public Object {
  public:
   // Excludes HeaderSize().
   intptr_t size() const { return abs(raw_ptr()->size_); }
   bool HasSingleEntryPoint() const { return raw_ptr()->size_ >= 0; }
 
-  uword PayloadStart() const {
-    return PayloadStart(raw());
-  }
-  uword CheckedEntryPoint() const {
-    return CheckedEntryPoint(raw());
-  }
-  uword UncheckedEntryPoint() const {
-    return UncheckedEntryPoint(raw());
-  }
+  uword PayloadStart() const { return PayloadStart(raw()); }
+  uword CheckedEntryPoint() const { return CheckedEntryPoint(raw()); }
+  uword UncheckedEntryPoint() const { return UncheckedEntryPoint(raw()); }
   static uword PayloadStart(RawInstructions* instr) {
     return reinterpret_cast<uword>(instr->ptr()) + HeaderSize();
   }
 
 #if defined(TARGET_ARCH_IA32)
   static const intptr_t kCheckedEntryOffset = 0;
   static const intptr_t kUncheckedEntryOffset = 0;
 #elif defined(TARGET_ARCH_X64)
   static const intptr_t kCheckedEntryOffset = 16;
   static const intptr_t kUncheckedEntryOffset = 38;
@@ skipping 21 matching lines @@
     return entry;
   }
   static uword UncheckedEntryPoint(RawInstructions* instr) {
     uword entry = PayloadStart(instr);
     if (instr->ptr()->size_ < 0) {
       entry += kUncheckedEntryOffset;
     }
     return entry;
   }
 
-  static const intptr_t kMaxElements = (kMaxInt32 -
-                                        (sizeof(RawInstructions) +
-                                         sizeof(RawObject) +
-                                         (2 * OS::kMaxPreferredCodeAlignment)));
+  static const intptr_t kMaxElements =
+      (kMaxInt32 - (sizeof(RawInstructions) + sizeof(RawObject) +
+                    (2 * OS::kMaxPreferredCodeAlignment)));
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawInstructions) ==
            OFFSET_OF_RETURNED_VALUE(RawInstructions, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t size) {
-    intptr_t instructions_size = Utils::RoundUp(size,
-                                                OS::PreferredCodeAlignment());
+    intptr_t instructions_size =
+        Utils::RoundUp(size, OS::PreferredCodeAlignment());
     intptr_t result = instructions_size + HeaderSize();
     ASSERT(result % OS::PreferredCodeAlignment() == 0);
     return result;
   }
 
   static intptr_t HeaderSize() {
     intptr_t alignment = OS::PreferredCodeAlignment();
     return Utils::RoundUp(sizeof(RawInstructions), alignment);
   }
 
   static RawInstructions* FromPayloadStart(uword payload_start) {
-    return reinterpret_cast<RawInstructions*>(
-        payload_start - HeaderSize() + kHeapObjectTag);
+    return reinterpret_cast<RawInstructions*>(payload_start - HeaderSize() +
+                                              kHeapObjectTag);
   }
 
   bool Equals(const Instructions& other) const {
     if (size() != other.size()) {
       return false;
     }
     NoSafepointScope no_safepoint;
     return memcmp(raw_ptr(), other.raw_ptr(), InstanceSize(size())) == 0;
   }
 
@@ skipping 27 matching lines @@
               RawLocalVarDescriptors::VarInfo* info) const;
 
   void GetInfo(intptr_t var_index, RawLocalVarDescriptors::VarInfo* info) const;
 
   static const intptr_t kBytesPerElement =
       sizeof(RawLocalVarDescriptors::VarInfo);
   static const intptr_t kMaxElements = RawLocalVarDescriptors::kMaxIndex;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawLocalVarDescriptors) ==
-        OFFSET_OF_RETURNED_VALUE(RawLocalVarDescriptors, names));
+           OFFSET_OF_RETURNED_VALUE(RawLocalVarDescriptors, names));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(sizeof(RawLocalVarDescriptors)
-        + (len * kWordSize)  // RawStrings for names.
+    return RoundedAllocationSize(
+        sizeof(RawLocalVarDescriptors) +
+        (len * kWordSize)  // RawStrings for names.
         + (len * sizeof(RawLocalVarDescriptors::VarInfo)));
   }
 
   static RawLocalVarDescriptors* New(intptr_t num_variables);
 
   static const char* KindToCString(RawLocalVarDescriptors::VarInfoKind kind);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors, Object);
   friend class Class;
@@ skipping 38 matching lines @@
   class Iterator : ValueObject {
    public:
     Iterator(const PcDescriptors& descriptors, intptr_t kind_mask)
         : descriptors_(descriptors),
           kind_mask_(kind_mask),
           byte_index_(0),
           cur_pc_offset_(0),
           cur_kind_(0),
           cur_deopt_id_(0),
           cur_token_pos_(0),
-          cur_try_index_(0) {
-    }
+          cur_try_index_(0) {}
 
     bool MoveNext() {
       // Moves to record that matches kind_mask_.
       while (byte_index_ < descriptors_.Length()) {
         int32_t merged_kind_try = descriptors_.DecodeInteger(&byte_index_);
         cur_kind_ =
             RawPcDescriptors::MergedKindTry::DecodeKind(merged_kind_try);
         cur_try_index_ =
             RawPcDescriptors::MergedKindTry::DecodeTryIndex(merged_kind_try);
 
@@ skipping 93 matching lines @@
   static void Dump(const CodeSourceMap& code_source_map,
                    const Code& code,
                    const Function& function);
 
   class Iterator : ValueObject {
    public:
     explicit Iterator(const CodeSourceMap& code_source_map)
         : code_source_map_(code_source_map),
           byte_index_(0),
           cur_pc_offset_(0),
-          cur_token_pos_(0) {
-    }
+          cur_token_pos_(0) {}
 
     bool MoveNext() {
       // Moves to the next record.
       while (byte_index_ < code_source_map_.Length()) {
         cur_pc_offset_ += code_source_map_.DecodeInteger(&byte_index_);
         cur_token_pos_ += code_source_map_.DecodeInteger(&byte_index_);
 
         return true;
       }
       return false;
@@ skipping 59 matching lines @@
 
   static const intptr_t kMaxLengthInBytes = kSmiMax;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawStackmap) == OFFSET_OF_RETURNED_VALUE(RawStackmap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
     ASSERT(length >= 0);
     // The stackmap payload is in an array of bytes.
-    intptr_t payload_size =
-        Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
+    intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
     return RoundedAllocationSize(sizeof(RawStackmap) + payload_size);
   }
   static RawStackmap* New(intptr_t pc_offset,
                           BitmapBuilder* bmap,
                           intptr_t register_bit_count);
 
   static RawStackmap* New(intptr_t length,
                           intptr_t register_bit_count,
                           intptr_t pc_offset);
 
  private:
   void SetLength(intptr_t length) const {
-      StoreNonPointer(&raw_ptr()->length_, length);
+    StoreNonPointer(&raw_ptr()->length_, length);
   }
 
   bool InRange(intptr_t index) const { return index < Length(); }
 
   bool GetBit(intptr_t bit_index) const;
   void SetBit(intptr_t bit_index, bool value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
   friend class BitmapBuilder;
   friend class Class;
@@ skipping 24 matching lines @@
   bool HasCatchAll(intptr_t try_index) const;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawExceptionHandlers) ==
            OFFSET_OF_RETURNED_VALUE(RawExceptionHandlers, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(
         sizeof(RawExceptionHandlers) +
-            (len * sizeof(RawExceptionHandlers::HandlerInfo)));
+        (len * sizeof(RawExceptionHandlers::HandlerInfo)));
   }
 
   static RawExceptionHandlers* New(intptr_t num_handlers);
   static RawExceptionHandlers* New(const Array& handled_types_data);
 
   // We would have a VisitPointers function here to traverse the
   // exception handler table to visit objects if any in the table.
 
  private:
   // Pick somewhat arbitrary maximum number of exception handlers
@@ skipping 30 matching lines @@
   static intptr_t NumMaterializations(const GrowableArray<DeoptInstr*>&);
 
   // Unpack the entire translation into an array of deoptimization
   // instructions.  This copies any shared suffixes into the array.
   static void Unpack(const Array& table,
                      const TypedData& packed,
                      GrowableArray<DeoptInstr*>* instructions);
 
   // Size of the frame part of the translation not counting kMaterializeObject
   // instructions in the prefix.
-  static const char* ToCString(const Array& table,
-                               const TypedData& packed);
+  static const char* ToCString(const Array& table, const TypedData& packed);
 
   // Returns true iff decompression yields the same instructions as the
   // original.
   static bool VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
                                   const Array& deopt_table,
                                   const TypedData& packed);
 
 
  private:
   static void UnpackInto(const Array& table,
@@ skipping 33 matching lines @@
   }
 
   intptr_t pointer_offsets_length() const {
     return PtrOffBits::decode(raw_ptr()->state_bits_);
   }
 
   bool is_optimized() const {
     return OptimizedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_optimized(bool value) const;
-  bool is_alive() const {
-    return AliveBit::decode(raw_ptr()->state_bits_);
-  }
+  bool is_alive() const { return AliveBit::decode(raw_ptr()->state_bits_); }
   void set_is_alive(bool value) const;
 
   uword PayloadStart() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.PayloadStart();
   }
   uword UncheckedEntryPoint() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.UncheckedEntryPoint();
   }
   uword CheckedEntryPoint() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.CheckedEntryPoint();
   }
   intptr_t Size() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.size();
   }
-  RawObjectPool* GetObjectPool() const {
-    return object_pool();
-  }
+  RawObjectPool* GetObjectPool() const { return object_pool(); }
   bool ContainsInstructionAt(uword addr) const {
     const Instructions& instr = Instructions::Handle(instructions());
     const uword offset = addr - instr.PayloadStart();
     return offset < static_cast<uword>(instr.size());
   }
 
   // Returns true if there is a debugger breakpoint set in this code object.
   bool HasBreakpoint() const;
 
   RawPcDescriptors* pc_descriptors() const {
@@ skipping 31 matching lines @@
   RawArray* deopt_info_array() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->deopt_info_array_;
 #endif
   }
   void set_deopt_info_array(const Array& array) const;
 
-  RawArray* stackmaps() const {
-    return raw_ptr()->stackmaps_;
-  }
+  RawArray* stackmaps() const { return raw_ptr()->stackmaps_; }
   void set_stackmaps(const Array& maps) const;
-  RawStackmap* GetStackmap(
-      uint32_t pc_offset, Array* stackmaps, Stackmap* map) const;
+  RawStackmap* GetStackmap(uint32_t pc_offset,
+                           Array* stackmaps,
+                           Stackmap* map) const;
 
   enum {
     kSCallTableOffsetEntry = 0,
     kSCallTableFunctionEntry = 1,
     kSCallTableCodeEntry = 2,
     kSCallTableEntryLength = 3,
   };
 
   void set_static_calls_target_table(const Array& value) const;
   RawArray* static_calls_target_table() const {
@@ skipping 30 matching lines @@
 
     intptr_t PCOffsetAt(intptr_t idx) const;
     RawString* CommentAt(intptr_t idx) const;
 
    private:
     explicit Comments(const Array& comments);
 
     // Layout of entries describing comments.
     enum {
       kPCOffsetEntry = 0,  // PC offset to a comment as a Smi.
-      kCommentEntry,  // Comment text as a String.
+      kCommentEntry,       // Comment text as a String.
       kNumberOfEntries
     };
 
     const Array& comments_;
 
     friend class Code;
 
     DISALLOW_COPY_AND_ASSIGN(Comments);
   };
 
@@ skipping 69 matching lines @@
     StorePointer(&raw_ptr()->exception_handlers_, handlers.raw());
   }
 
   // TODO(turnidge): Consider dropping this function and making
   // everybody use owner().  Currently this function is misused - even
   // while generating the snapshot.
   RawFunction* function() const {
     return reinterpret_cast<RawFunction*>(raw_ptr()->owner_);
   }
 
-  RawObject* owner() const {
-    return raw_ptr()->owner_;
-  }
+  RawObject* owner() const { return raw_ptr()->owner_; }
 
   void set_owner(const Function& function) const {
     ASSERT(function.IsOld());
     StorePointer(&raw_ptr()->owner_,
                  reinterpret_cast<RawObject*>(function.raw()));
   }
 
   void set_owner(const Class& cls) {
     ASSERT(cls.IsOld());
     StorePointer(&raw_ptr()->owner_, reinterpret_cast<RawObject*>(cls.raw()));
@@ skipping 53 matching lines @@
 
   void DisableStubCode() const;
 
   void Enable() const {
     if (!IsDisabled()) return;
     ASSERT(Thread::Current()->IsMutatorThread());
     ASSERT(instructions() != active_instructions());
     SetActiveInstructions(Instructions::Handle(instructions()));
   }
 
-  bool IsDisabled() const {
-    return instructions() != active_instructions();
-  }
+  bool IsDisabled() const { return instructions() != active_instructions(); }
 
  private:
   void set_state_bits(intptr_t bits) const;
 
   void set_object_pool(RawObjectPool* object_pool) const {
     StorePointer(&raw_ptr()->object_pool_, object_pool);
   }
 
   friend class RawObject;  // For RawObject::SizeFromClass().
   friend class RawCode;
   enum {
     kOptimizedBit = 0,
     kAliveBit = 1,
     kPtrOffBit = 2,
     kPtrOffSize = 30,
   };
 
   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
-  class PtrOffBits :
-      public BitField<int32_t, intptr_t, kPtrOffBit, kPtrOffSize> {};
+  class PtrOffBits
+      : public BitField<int32_t, intptr_t, kPtrOffBit, kPtrOffSize> {};
 
   class SlowFindRawCodeVisitor : public FindObjectVisitor {
    public:
-    explicit SlowFindRawCodeVisitor(uword pc) : pc_(pc) { }
-    virtual ~SlowFindRawCodeVisitor() { }
+    explicit SlowFindRawCodeVisitor(uword pc) : pc_(pc) {}
+    virtual ~SlowFindRawCodeVisitor() {}
 
     // Check if object matches find condition.
     virtual bool FindObject(RawObject* obj) const;
 
    private:
     const uword pc_;
 
     DISALLOW_COPY_AND_ASSIGN(SlowFindRawCodeVisitor);
   };
 
@@ skipping 162 matching lines @@
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawContextScope) ==
            OFFSET_OF_RETURNED_VALUE(RawContextScope, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(
-        sizeof(RawContextScope) + (len * kBytesPerElement));
+    return RoundedAllocationSize(sizeof(RawContextScope) +
+                                 (len * kBytesPerElement));
   }
 
   static RawContextScope* New(intptr_t num_variables, bool is_implicit);
 
  private:
   void set_num_variables(intptr_t num_variables) const {
     StoreNonPointer(&raw_ptr()->num_variables_, num_variables);
   }
 
   void set_is_implicit(bool is_implicit) const {
@@ skipping 16 matching lines @@
   static const intptr_t kInitialCapacity = 16;
   static const intptr_t kSpreadFactor = 7;
   static const double kLoadFactor;
 
   RawArray* buckets() const;
   void set_buckets(const Array& buckets) const;
 
   intptr_t mask() const;
   void set_mask(intptr_t mask) const;
 
-  RawString* target_name() const {
-    return raw_ptr()->target_name_;
-  }
+  RawString* target_name() const { return raw_ptr()->target_name_; }
 
-  RawArray* arguments_descriptor() const {
-    return raw_ptr()->args_descriptor_;
-  }
+  RawArray* arguments_descriptor() const { return raw_ptr()->args_descriptor_; }
 
   intptr_t filled_entry_count() const;
   void set_filled_entry_count(intptr_t num) const;
 
   static intptr_t buckets_offset() {
     return OFFSET_OF(RawMegamorphicCache, buckets_);
   }
   static intptr_t mask_offset() {
     return OFFSET_OF(RawMegamorphicCache, mask_);
   }
@@ skipping 41 matching lines @@
 };
 
 
 class SubtypeTestCache : public Object {
  public:
   enum Entries {
     kInstanceClassIdOrFunction = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
     kTestResult = 3,
-    kTestEntryLength  = 4,
+    kTestEntryLength = 4,
   };
 
   intptr_t NumberOfChecks() const;
   void AddCheck(const Object& instance_class_id_or_function,
                 const TypeArguments& instance_type_arguments,
                 const TypeArguments& instantiator_type_arguments,
                 const Bool& test_result) const;
   void GetCheck(intptr_t ix,
                 Object* instance_class_id_or_function,
                 TypeArguments* instance_type_arguments,
                 TypeArguments* instantiator_type_arguments,
                 Bool* test_result) const;
 
   static RawSubtypeTestCache* New();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSubtypeTestCache));
   }
 
   static intptr_t cache_offset() {
     return OFFSET_OF(RawSubtypeTestCache, cache_);
   }
 
  private:
-  RawArray* cache() const {
-    return raw_ptr()->cache_;
-  }
+  RawArray* cache() const { return raw_ptr()->cache_; }
 
   void set_cache(const Array& value) const;
 
   intptr_t TestEntryLength() const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache, Object);
   friend class Class;
 };
 
 
@@ skipping 42 matching lines @@
     return RoundedAllocationSize(sizeof(RawLanguageError));
   }
 
   // A null script means no source and a negative token_pos means no position.
   static RawLanguageError* NewFormatted(const Error& prev_error,
                                         const Script& script,
                                         TokenPosition token_pos,
                                         bool report_after_token,
                                         Report::Kind kind,
                                         Heap::Space space,
-                                        const char* format, ...)
-    PRINTF_ATTRIBUTE(7, 8);
+                                        const char* format,
+                                        ...) PRINTF_ATTRIBUTE(7, 8);
 
   static RawLanguageError* 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);
+                                         const char* format,
+                                         va_list args);
 
   static RawLanguageError* New(const String& formatted_message,
                                Report::Kind kind = Report::kError,
                                Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
   TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
 
  private:
-  RawError* previous_error() const {
-    return raw_ptr()->previous_error_;
-  }
+  RawError* previous_error() const { return raw_ptr()->previous_error_; }
   void set_previous_error(const Error& value) const;
 
   RawScript* script() const { return raw_ptr()->script_; }
   void set_script(const Script& value) const;
 
   void set_token_pos(TokenPosition value) const;
 
   bool report_after_token() const { return raw_ptr()->report_after_token_; }
   void set_report_after_token(bool value);
 
@@ skipping 107 matching lines @@
 
   // Returns true if all fields are OK for canonicalization.
   virtual bool CheckAndCanonicalizeFields(Thread* thread,
                                           const char** error_str) const;
 
 #if defined(DEBUG)
   // Check if instance is canonical.
   virtual bool CheckIsCanonical(Thread* thread) const;
 #endif  // DEBUG
 
-  RawObject* GetField(const Field& field) const {
-    return *FieldAddr(field);
-  }
+  RawObject* GetField(const Field& field) const { return *FieldAddr(field); }
 
   void SetField(const Field& field, const Object& value) const {
     field.RecordStore(value);
     StorePointer(FieldAddr(field), value.raw());
   }
 
   RawAbstractType* GetType() const;
 
   virtual RawTypeArguments* GetTypeArguments() const;
   virtual void SetTypeArguments(const TypeArguments& value) const;
 
   // Check if the type of this instance is a subtype of the given type.
   bool IsInstanceOf(const AbstractType& type,
                     const TypeArguments& type_instantiator,
                     Error* bound_error) const;
 
   bool IsValidNativeIndex(int index) const {
     return ((index >= 0) && (index < clazz()->ptr()->num_native_fields_));
   }
 
   intptr_t* NativeFieldsDataAddr() const;
   inline intptr_t GetNativeField(int index) const;
   inline void GetNativeFields(uint16_t num_fields,
                               intptr_t* field_values) const;
-  void SetNativeFields(uint16_t num_fields,
-                       const intptr_t* field_values) const;
+  void SetNativeFields(uint16_t num_fields, const intptr_t* field_values) const;
 
   uint16_t NumNativeFields() const {
     return clazz()->ptr()->num_native_fields_;
   }
 
   void SetNativeField(int index, intptr_t value) const;
 
   // If the instance is a callable object, i.e. a closure or the instance of a
   // class implementing a 'call' method, return true and set the function
   // (if not NULL) to call.
@@ skipping 36 matching lines @@
     return FieldAddrAtOffset(field.Offset());
   }
   RawObject** NativeFieldsAddr() const {
     return FieldAddrAtOffset(sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     StorePointer(FieldAddrAtOffset(offset), value.raw());
   }
   bool IsValidFieldOffset(intptr_t offset) const;
 
-  static intptr_t NextFieldOffset() {
-    return sizeof(RawInstance);
-  }
+  static intptr_t NextFieldOffset() { return sizeof(RawInstance); }
 
   // The follwoing raw methods are used for morphing.
   // They are needed due to the extraction of the class in IsValidFieldOffset.
   RawObject** RawFieldAddrAtOffset(intptr_t offset) const {
     return reinterpret_cast<RawObject**>(raw_value() - kHeapObjectTag + offset);
   }
   RawObject* RawGetFieldAtOffset(intptr_t offset) const {
     return *RawFieldAddrAtOffset(offset);
   }
   void RawSetFieldAtOffset(intptr_t offset, const Object& value) const {
@@ skipping 127 matching lines @@
   // Return a clone of this unfinalized type or the type itself if it is
   // already finalized. Apply recursively to type arguments, i.e. finalized
   // type arguments of an unfinalized type are not cloned, but shared.
   virtual RawAbstractType* CloneUnfinalized() const;
 
   // Return a clone of this uninstantiated type where all references to type
   // parameters are replaced with references to type parameters of the same name
   // but belonging to the new owner class.
   // Apply recursively to type arguments, i.e. instantiated type arguments of
   // an uninstantiated type are not cloned, but shared.
-  virtual RawAbstractType* CloneUninstantiated(
-      const Class& new_owner, TrailPtr trail = NULL) const;
+  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
+                                               TrailPtr trail = NULL) const;
 
   virtual RawInstance* CheckAndCanonicalize(Thread* thread,
                                             const char** error_str) const {
     return Canonicalize();
   }
 
   // Return the canonical version of this type.
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 
 #if defined(DEBUG)
@@ skipping 17 matching lines @@
   // the trail and return false.
   bool TestAndAddToTrail(TrailPtr* trail) const;
 
   // Return true if the pair <receiver, buddy> is contained in the trail.
   // Otherwise, if the trail is null, allocate a trail, add the pair <receiver,
   // buddy> to the trail and return false.
   // The receiver may be added several times, each time with a different buddy.
   bool TestAndAddBuddyToTrail(TrailPtr* trail, const AbstractType& buddy) const;
 
   // The name of this type, including the names of its type arguments, if any.
-  virtual RawString* Name() const {
-    return BuildName(kInternalName);
-  }
+  virtual RawString* Name() const { return BuildName(kInternalName); }
 
   // The name of this type, including the names of its type arguments, if any.
   // Names of internal classes are mapped to their public interfaces.
   virtual RawString* UserVisibleName() const {
     return BuildName(kUserVisibleName);
   }
 
   // Returns a formatted list of occuring types with their URI.
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   // The name of this type's class, i.e. without the type argument names of this
   // type.
   RawString* ClassName() const;
 
   // Check if this type represents the 'dynamic' type or if it is malformed,
   // since a malformed type is mapped to 'dynamic'.
   // Call IsMalformed() first, if distinction is required.
   bool IsDynamicType() const;
 
   // Check if this type represents the 'void' type.
   bool IsVoidType() const;
 
   // Check if this type represents the 'Null' type.
   bool IsNullType() const;
 
   bool IsObjectType() const {
-    return !IsFunctionType() &&
-        HasResolvedTypeClass() &&
-        Class::Handle(type_class()).IsObjectClass();
+    return !IsFunctionType() && HasResolvedTypeClass() &&
+           Class::Handle(type_class()).IsObjectClass();
   }
 
   // Check if this type represents the 'bool' type.
   bool IsBoolType() const;
 
   // Check if this type represents the 'int' type.
   bool IsIntType() const;
 
   // Check if this type represents the 'double' type.
   bool IsDoubleType() const;
@@ skipping 28 matching lines @@
                    TrailPtr bound_trail,
                    Heap::Space space) const {
     return TypeTest(kIsSubtypeOf, other, bound_error, bound_trail, space);
   }
 
   // Check the 'more specific' relationship.
   bool IsMoreSpecificThan(const AbstractType& other,
                           Error* bound_error,
                           TrailPtr bound_trail,
                           Heap::Space space) const {
-    return TypeTest(kIsMoreSpecificThan, other,
-                    bound_error, bound_trail, space);
+    return TypeTest(kIsMoreSpecificThan, other, bound_error, bound_trail,
+                    space);
   }
 
  private:
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractType& other,
                 Error* bound_error,
                 TrailPtr bound_trail,
                 Heap::Space space) const;
 
@@ skipping 15 matching lines @@
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
 // opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does not
 // relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
 class Type : public AbstractType {
  public:
   static intptr_t type_class_id_offset() {
     return OFFSET_OF(RawType, type_class_id_);
   }
   virtual bool IsFinalized() const {
-    return
-        (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) ||
-        (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated);
+    return (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) ||
+           (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated);
   }
   virtual void SetIsFinalized() const;
   void ResetIsFinalized() const;  // Ignore current state and set again.
   virtual bool IsBeingFinalized() const {
     return raw_ptr()->type_state_ == RawType::kBeingFinalized;
   }
   virtual void SetIsBeingFinalized() const;
   virtual bool IsMalformed() const;
   virtual bool IsMalbounded() const;
   virtual bool IsMalformedOrMalbounded() const;
@@ skipping 21 matching lines @@
   virtual bool IsFunctionType() const {
     return signature() != Function::null();
   }
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawAbstractType* CloneUnfinalized() const;
-  virtual RawAbstractType* CloneUninstantiated(
-      const Class& new_owner,
-      TrailPtr trail = NULL) const;
+  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
+                                               TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if type is canonical.
   virtual bool CheckIsCanonical(Thread* thread) const;
 #endif  // DEBUG
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
@@ skipping 100 matching lines @@
   virtual RawClass* type_class() const {
     return AbstractType::Handle(type()).type_class();
   }
   virtual RawTypeArguments* arguments() const {
     return AbstractType::Handle(type()).arguments();
   }
   virtual TokenPosition token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
   virtual bool IsInstantiated(TrailPtr trail = NULL) const;
-  virtual bool IsEquivalent(const Instance& other,
-                            TrailPtr trail = NULL) const;
+  virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return true; }
   virtual RawTypeRef* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
-  virtual RawTypeRef* CloneUninstantiated(
-      const Class& new_owner,
-      TrailPtr trail = NULL) const;
+  virtual RawTypeRef* CloneUninstantiated(const Class& new_owner,
+                                          TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if typeref is canonical.
   virtual bool CheckIsCanonical(Thread* thread) const;
 #endif  // DEBUG
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
@@ skipping 53 matching lines @@
   // Returns true if bounded_type is below upper_bound, otherwise return false
   // and set bound_error if both bounded_type and upper_bound are instantiated.
   // If one or both are not instantiated, returning false only means that the
   // bound cannot be checked yet and this is not an error.
   bool CheckBound(const AbstractType& bounded_type,
                   const AbstractType& upper_bound,
                   Error* bound_error,
                   TrailPtr bound_trail,
                   Heap::Space space) const;
   virtual TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const {
-    return false;
-  }
+  virtual bool IsInstantiated(TrailPtr trail = NULL) const { return false; }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return false; }
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawAbstractType* CloneUnfinalized() const;
-  virtual RawAbstractType* CloneUninstantiated(
-      const Class& new_owner, TrailPtr trail = NULL) const;
+  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
+                                               TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
 #if defined(DEBUG)
   // Check if type parameter is canonical.
-  virtual bool CheckIsCanonical(Thread* thread) const {
-    return true;
-  }
+  virtual bool CheckIsCanonical(Thread* thread) const { return true; }
 #endif  // DEBUG
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
   // Only one of parameterized_class and parameterized_function is non-null.
@@ skipping 70 matching lines @@
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawAbstractType* CloneUnfinalized() const;
-  virtual RawAbstractType* CloneUninstantiated(
-      const Class& new_owner, TrailPtr trail = NULL) const;
+  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
+                                               TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
 #if defined(DEBUG)
   // Check if bounded type is canonical.
-  virtual bool CheckIsCanonical(Thread* thread) const {
-    return true;
-  }
+  virtual bool CheckIsCanonical(Thread* thread) const { return true; }
 #endif  // DEBUG
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawBoundedType));
   }
 
   static RawBoundedType* New(const AbstractType& type,
@@ skipping 111 matching lines @@
   }
   virtual bool Equals(const Instance& other) const;
 
   virtual RawObject* HashCode() const { return raw(); }
 
   virtual bool IsZero() const;
   virtual bool IsNegative() const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
-  virtual int64_t AsTruncatedInt64Value() const {
-    return AsInt64Value();
-  }
+  virtual int64_t AsTruncatedInt64Value() const { return AsInt64Value(); }
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual bool FitsIntoSmi() const;
 
   // Returns 0, -1 or 1.
   virtual int CompareWith(const Integer& other) const;
 
   // Return the most compact presentation of an integer.
   RawInteger* AsValidInteger() const;
 
@@ skipping 10 matching lines @@
   friend class Class;
 };
 
 
 class Smi : public Integer {
  public:
   static const intptr_t kBits = kSmiBits;
   static const intptr_t kMaxValue = kSmiMax;
   static const intptr_t kMinValue = kSmiMin;
 
-  intptr_t Value() const {
-    return ValueFromRaw(raw_value());
-  }
+  intptr_t Value() const { return ValueFromRaw(raw_value()); }
 
   virtual bool Equals(const Instance& other) const;
   virtual bool IsZero() const { return Value() == 0; }
   virtual bool IsNegative() const { return Value() < 0; }
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual bool FitsIntoSmi() const { return true; }
@@ skipping 66 matching lines @@
 
 
 class Mint : public Integer {
  public:
   static const intptr_t kBits = 63;  // 64-th bit is sign.
   static const int64_t kMaxValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x7FFFFFFF, FFFFFFFF));
   static const int64_t kMinValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x80000000, 00000000));
 
-  int64_t value() const {
-    return raw_ptr()->value_;
-  }
+  int64_t value() const { return raw_ptr()->value_; }
   static intptr_t value_offset() { return OFFSET_OF(RawMint, value_); }
 
-  virtual bool IsZero() const {
-    return value() == 0;
-  }
-  virtual bool IsNegative() const {
-    return value() < 0;
-  }
+  virtual bool IsZero() const { return value() == 0; }
+  virtual bool IsNegative() const { return value() < 0; }
 
   virtual bool Equals(const Instance& other) const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual bool FitsIntoSmi() const;
 
   virtual int CompareWith(const Integer& other) const;
@@ skipping 14 matching lines @@
   void set_value(int64_t value) const;
 
   MINT_OBJECT_IMPLEMENTATION(Mint, Integer, Integer);
   friend class Class;
   friend class Number;
 };
 
 
 class Bigint : public Integer {
  public:
-  virtual bool IsZero() const { return Used() == 0;}
+  virtual bool IsZero() const { return Used() == 0; }
   virtual bool IsNegative() const { return Neg(); }
   virtual bool Equals(const Instance& other) const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual int64_t AsTruncatedInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
 
   virtual int CompareWith(const Integer& other) const;
 
@@ skipping 27 matching lines @@
   const char* ToDecCString(Zone* zone) const;
   const char* ToHexCString(Zone* zone) const;
 
   static const intptr_t kBitsPerDigit = 32;  // Same as _Bigint._DIGIT_BITS
   static const intptr_t kBytesPerDigit = 4;
   static const int64_t kDigitBase = 1LL << kBitsPerDigit;
   static const int64_t kDigitMask = kDigitBase - 1;
 
   static RawBigint* New(Heap::Space space = Heap::kNew);  // For snapshots.
 
-  static RawBigint* New(bool neg, intptr_t used, const TypedData& digits,
+  static RawBigint* New(bool neg,
+                        intptr_t used,
+                        const TypedData& digits,
                         Heap::Space space = Heap::kNew);
 
-  static RawBigint* NewFromInt64(int64_t value,
+  static RawBigint* NewFromInt64(int64_t value, Heap::Space space = Heap::kNew);
+
+  static RawBigint* NewFromUint64(uint64_t value,
                                   Heap::Space space = Heap::kNew);
 
-  static RawBigint* NewFromUint64(uint64_t value,
-                                   Heap::Space space = Heap::kNew);
-
-  static RawBigint* NewFromShiftedInt64(int64_t value, intptr_t shift,
-                                         Heap::Space space = Heap::kNew);
+  static RawBigint* NewFromShiftedInt64(int64_t value,
+                                        intptr_t shift,
+                                        Heap::Space space = Heap::kNew);
 
   static RawBigint* NewFromCString(const char* str,
-                                    Heap::Space space = Heap::kNew);
+                                   Heap::Space space = Heap::kNew);
 
   // Returns a canonical Bigint object allocated in the old gen space.
   static RawBigint* NewCanonical(const String& str);
 
  private:
   void SetNeg(bool value) const;
   void SetUsed(intptr_t value) const;
   void set_digits(const TypedData& value) const;
 
   // Convenience helpers.
   static RawTypedData* NewDigits(intptr_t length,
                                  Heap::Space space = Heap::kNew);
   static uint32_t DigitAt(const TypedData& digits, intptr_t index);
   static void SetDigitAt(const TypedData& digits,
                          intptr_t index,
                          uint32_t value);
 
-  static RawTypedData* NewDigitsFromHexCString(const char* str, intptr_t* used,
+  static RawTypedData* NewDigitsFromHexCString(const char* str,
+                                               intptr_t* used,
                                                Heap::Space space = Heap::kNew);
 
-  static RawTypedData* NewDigitsFromDecCString(const char* str, intptr_t* used,
+  static RawTypedData* NewDigitsFromDecCString(const char* str,
+                                               intptr_t* used,
                                                Heap::Space space = Heap::kNew);
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
   friend class Class;
 };
 
 
 // Class Double represents class Double in corelib_impl, which implements
 // abstract class double in corelib.
 class Double : public Number {
  public:
-  double value() const {
-    return raw_ptr()->value_;
-  }
+  double value() const { return raw_ptr()->value_; }
 
   bool BitwiseEqualsToDouble(double value) const;
   virtual bool OperatorEquals(const Instance& other) const;
   virtual bool CanonicalizeEquals(const Instance& other) const;
   virtual uword ComputeCanonicalTableHash() const {
     UNREACHABLE();
     return 0;
   }
 
   static RawDouble* New(double d, Heap::Space space = Heap::kNew);
@@ skipping 37 matching lines @@
   // All strings share the same maximum element count to keep things
   // simple.  We choose a value that will prevent integer overflow for
   // 2 byte strings, since it is the worst case.
   static const intptr_t kSizeofRawString =
       sizeof(RawInstance) + (2 * kWordSize);
   static const intptr_t kMaxElements = kSmiMax / kTwoByteChar;
 
   class CodePointIterator : public ValueObject {
    public:
     explicit CodePointIterator(const String& str)
-        : str_(str),
-          ch_(0),
-          index_(-1),
-          end_(str.Length()) {
+        : str_(str), ch_(0), index_(-1), end_(str.Length()) {
       ASSERT(!str_.IsNull());
     }
 
     CodePointIterator(const String& str, intptr_t start, intptr_t length)
-        : str_(str),
-          ch_(0),
-          index_(start - 1),
-          end_(start + length) {
+        : str_(str), ch_(0), index_(start - 1), end_(start + length) {
       ASSERT(start >= 0);
       ASSERT(end_ <= str.Length());
     }
 
     int32_t Current() const {
       ASSERT(index_ >= 0);
       ASSERT(index_ < end_);
       return ch_;
     }
 
@@ skipping 45 matching lines @@
   uint16_t CharAt(intptr_t index) const;
 
   Scanner::CharAtFunc CharAtFunc() const;
 
   intptr_t CharSize() const;
 
   inline bool Equals(const String& str) const;
 
   bool Equals(const String& str,
               intptr_t begin_index,  // begin index on 'str'.
-              intptr_t len) const;  // len on 'str'.
+              intptr_t len) const;   // len on 'str'.
 
   // Compares to a '\0' terminated array of UTF-8 encoded characters.
   bool Equals(const char* cstr) const;
 
   // Compares to an array of Latin-1 encoded characters.
   bool EqualsLatin1(const uint8_t* characters, intptr_t len) const {
     return Equals(characters, len);
   }
 
   // Compares to an array of UTF-16 encoded characters.
@@ skipping 161 matching lines @@
                               Heap::Space space = Heap::kNew);
 
   static RawString* ToUpperCase(const String& str,
                                 Heap::Space space = Heap::kNew);
   static RawString* ToLowerCase(const String& str,
                                 Heap::Space space = Heap::kNew);
 
   static RawString* ScrubName(const String& name);
   static RawString* ScrubNameRetainPrivate(const String& name);
 
-  static bool EqualsIgnoringPrivateKey(const String& str1,
-                                       const String& str2);
+  static bool EqualsIgnoringPrivateKey(const String& str1, const String& str2);
 
   static RawString* NewFormatted(const char* format, ...)
       PRINTF_ATTRIBUTE(1, 2);
   static RawString* NewFormatted(Heap::Space space, const char* format, ...)
       PRINTF_ATTRIBUTE(2, 3);
-  static RawString* NewFormattedV(const char* format, va_list args,
+  static RawString* NewFormattedV(const char* format,
+                                  va_list args,
                                   Heap::Space space = Heap::kNew);
 
   static bool ParseDouble(const String& str,
                           intptr_t start,
                           intptr_t end,
                           double* result);
 
  protected:
   // These two operate on an array of Latin-1 encoded characters.
   // They are protected to avoid mistaking Latin-1 for UTF-8, but used
   // by friendly templated code (e.g., Symbols).
   bool Equals(const uint8_t* characters, intptr_t len) const;
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
   void SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     StoreSmi(&raw_ptr()->hash_, Smi::New(value));
   }
 
-  template<typename HandleType, typename ElementType, typename CallbackType>
+  template <typename HandleType, typename ElementType, typename CallbackType>
   static void ReadFromImpl(SnapshotReader* reader,
                            String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            CallbackType new_symbol,
                            Snapshot::Kind kind);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 
   friend class Class;
   friend class Symbols;
   friend class StringSlice;  // SetHash
-  template<typename CharType> friend class CharArray;  // SetHash
+  template <typename CharType>
+  friend class CharArray;     // SetHash
   friend class ConcatString;  // SetHash
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   // So that SkippedCodeFunctions can print a debug string from a NoHandleScope.
   friend class SkippedCodeFunctions;
   friend class RawOneByteString;
   friend class RODataSerializationCluster;  // SetHash
 };
@@ skipping 22 matching lines @@
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) ==
            OFFSET_OF_RETURNED_VALUE(RawOneByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawOneByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
-    return String::RoundedAllocationSize(
-        sizeof(RawOneByteString) + (len * kBytesPerElement));
+    return String::RoundedAllocationSize(sizeof(RawOneByteString) +
+                                         (len * kBytesPerElement));
   }
 
-  static RawOneByteString* New(intptr_t len,
-                               Heap::Space space);
+  static RawOneByteString* New(intptr_t len, Heap::Space space);
   static RawOneByteString* New(const char* c_string,
                                Heap::Space space = Heap::kNew) {
-    return New(reinterpret_cast<const uint8_t*>(c_string),
-               strlen(c_string),
+    return New(reinterpret_cast<const uint8_t*>(c_string), strlen(c_string),
                space);
   }
   static RawOneByteString* New(const uint8_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const int32_t* characters,
                                intptr_t len,
                                Heap::Space space);
-  static RawOneByteString* New(const String& str,
-                               Heap::Space space);
+  static RawOneByteString* New(const String& str, Heap::Space space);
   // 'other' must be OneByteString.
   static RawOneByteString* New(const String& other_one_byte_string,
                                intptr_t other_start_index,
                                intptr_t other_len,
                                Heap::Space space);
 
   static RawOneByteString* New(const TypedData& other_typed_data,
                                intptr_t other_start_index,
                                intptr_t other_len,
                                Heap::Space space = Heap::kNew);
@@ skipping 93 matching lines @@
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) ==
            OFFSET_OF_RETURNED_VALUE(RawTwoByteString, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(sizeof(RawTwoByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
-    return String::RoundedAllocationSize(
-        sizeof(RawTwoByteString) + (len * kBytesPerElement));
+    return String::RoundedAllocationSize(sizeof(RawTwoByteString) +
+                                         (len * kBytesPerElement));
   }
 
-  static RawTwoByteString* New(intptr_t len,
-                               Heap::Space space);
+  static RawTwoByteString* New(intptr_t len, Heap::Space space);
   static RawTwoByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(intptr_t utf16_len,
                                const int32_t* characters,
                                intptr_t len,
                                Heap::Space space);
-  static RawTwoByteString* New(const String& str,
-                               Heap::Space space);
+  static RawTwoByteString* New(const String& str, Heap::Space space);
 
   static RawTwoByteString* New(const TypedData& other_typed_data,
                                intptr_t other_start_index,
                                intptr_t other_len,
                                Heap::Space space = Heap::kNew);
 
   static RawTwoByteString* New(const ExternalTypedData& other_typed_data,
                                intptr_t other_start_index,
                                intptr_t other_len,
                                Heap::Space space = Heap::kNew);
@@ skipping 215 matching lines @@
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
 };
 
 
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
-  bool value() const {
-    return raw_ptr()->value_;
-  }
+  bool value() const { return raw_ptr()->value_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawBool));
   }
 
-  static const Bool& True() {
-    return Object::bool_true();
-  }
+  static const Bool& True() { return Object::bool_true(); }
 
-  static const Bool& False() {
-    return Object::bool_false();
-  }
+  static const Bool& False() { return Object::bool_false(); }
 
   static const Bool& Get(bool value) {
     return value ? Bool::True() : Bool::False();
   }
 
  private:
   void set_value(bool value) const {
     StoreNonPointer(&raw_ptr()->value_, value);
   }
 
@@ skipping 18 matching lines @@
     return Smi::Value(raw_ptr()->length_);
   }
   static intptr_t length_offset() { return OFFSET_OF(RawArray, length_); }
   static intptr_t data_offset() {
     return OFFSET_OF_RETURNED_VALUE(RawArray, data);
   }
   static intptr_t element_offset(intptr_t index) {
     return OFFSET_OF_RETURNED_VALUE(RawArray, data) + kWordSize * index;
   }
 
-  RawObject* At(intptr_t index) const {
-    return *ObjectAddr(index);
-  }
+  RawObject* At(intptr_t index) const { return *ObjectAddr(index); }
   void SetAt(intptr_t index, const Object& value) const {
     // TODO(iposva): Add storing NoSafepointScope.
     StorePointer(ObjectAddr(index), value.raw());
   }
 
-  bool IsImmutable() const {
-    return raw()->GetClassId() == kImmutableArrayCid;
-  }
+  bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
 
   virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
   virtual void SetTypeArguments(const TypeArguments& value) const {
     // An Array is raw or takes one type argument. However, its type argument
     // vector may be longer than 1 due to a type optimization reusing the type
     // argument vector of the instantiator.
     ASSERT(value.IsNull() ||
            ((value.Length() >= 1) &&
@@ skipping 87 matching lines @@
   static RawImmutableArray* New(intptr_t len, Heap::Space space = Heap::kNew);
 
   static RawImmutableArray* ReadFrom(SnapshotReader* reader,
                                      intptr_t object_id,
                                      intptr_t tags,
                                      Snapshot::Kind kind,
                                      bool as_reference);
 
   static const ClassId kClassId = kImmutableArrayCid;
 
-  static intptr_t InstanceSize() {
-    return Array::InstanceSize();
-  }
+  static intptr_t InstanceSize() { return Array::InstanceSize(); }
 
   static intptr_t InstanceSize(intptr_t len) {
     return Array::InstanceSize(len);
   }
 
  private:
   static intptr_t NextFieldOffset() {
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
@@ skipping 47 matching lines @@
   void Grow(intptr_t new_capacity, Heap::Space space = Heap::kNew) const;
   RawObject* RemoveLast() const;
 
   virtual RawTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
   virtual void SetTypeArguments(const TypeArguments& value) const {
     // A GrowableObjectArray is raw or takes one type argument. However, its
     // type argument vector may be longer than 1 due to a type optimization
     // reusing the type argument vector of the instantiator.
-    ASSERT(value.IsNull() ||
-           ((value.Length() >= 1) &&
-            value.IsInstantiated() &&
-            value.IsCanonical()));
+    ASSERT(value.IsNull() || ((value.Length() >= 1) && value.IsInstantiated() &&
+                              value.IsCanonical()));
     const Array& contents = Array::Handle(data());
     contents.SetTypeArguments(value);
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
   // We don't expect a growable object array to be canonicalized.
   virtual bool CanonicalizeEquals(const Instance& other) const {
     UNREACHABLE();
     return false;
   }
@@ skipping 42 matching lines @@
   static const int kDefaultInitialCapacity = 4;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
 class Float32x4 : public Instance {
  public:
-  static RawFloat32x4* New(float value0, float value1, float value2,
-                           float value3, Heap::Space space = Heap::kNew);
+  static RawFloat32x4* New(float value0,
+                           float value1,
+                           float value2,
+                           float value3,
+                           Heap::Space space = Heap::kNew);
   static RawFloat32x4* New(simd128_value_t value,
                            Heap::Space space = Heap::kNew);
 
   float x() const;
   float y() const;
   float z() const;
   float w() const;
 
   void set_x(float x) const;
   void set_y(float y) const;
   void set_z(float z) const;
   void set_w(float w) const;
 
   simd128_value_t value() const;
   void set_value(simd128_value_t value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFloat32x4));
   }
 
-  static intptr_t value_offset() {
-    return OFFSET_OF(RawFloat32x4, value_);
-  }
+  static intptr_t value_offset() { return OFFSET_OF(RawFloat32x4, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float32x4, Instance);
   friend class Class;
 };
 
 
 class Int32x4 : public Instance {
  public:
-  static RawInt32x4* New(int32_t value0, int32_t value1, int32_t value2,
-                          int32_t value3, Heap::Space space = Heap::kNew);
-  static RawInt32x4* New(simd128_value_t value,
-                          Heap::Space space = Heap::kNew);
+  static RawInt32x4* New(int32_t value0,
+                         int32_t value1,
+                         int32_t value2,
+                         int32_t value3,
+                         Heap::Space space = Heap::kNew);
+  static RawInt32x4* New(simd128_value_t value, Heap::Space space = Heap::kNew);
 
   int32_t x() const;
   int32_t y() const;
   int32_t z() const;
   int32_t w() const;
 
   void set_x(int32_t x) const;
   void set_y(int32_t y) const;
   void set_z(int32_t z) const;
   void set_w(int32_t w) const;
 
   simd128_value_t value() const;
   void set_value(simd128_value_t value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawInt32x4));
   }
 
-  static intptr_t value_offset() {
-    return OFFSET_OF(RawInt32x4, value_);
-  }
+  static intptr_t value_offset() { return OFFSET_OF(RawInt32x4, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Int32x4, Instance);
   friend class Class;
 };
 
 
 class Float64x2 : public Instance {
  public:
-  static RawFloat64x2* New(double value0, double value1,
+  static RawFloat64x2* New(double value0,
+                           double value1,
                            Heap::Space space = Heap::kNew);
   static RawFloat64x2* New(simd128_value_t value,
                            Heap::Space space = Heap::kNew);
 
   double x() const;
   double y() const;
 
   void set_x(double x) const;
   void set_y(double y) const;
 
   simd128_value_t value() const;
   void set_value(simd128_value_t value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFloat64x2));
   }
 
-  static intptr_t value_offset() {
-    return OFFSET_OF(RawFloat64x2, value_);
-  }
+  static intptr_t value_offset() { return OFFSET_OF(RawFloat64x2, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float64x2, Instance);
   friend class Class;
 };
 
 
 class TypedData : public Instance {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
@@ skipping 17 matching lines @@
   }
 
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* DataAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset == 0) ||
            ((byte_offset > 0) && (byte_offset < LengthInBytes())));
-    return reinterpret_cast<void*>(
-        UnsafeMutableNonPointer(raw_ptr()->data()) + byte_offset);
+    return reinterpret_cast<void*>(UnsafeMutableNonPointer(raw_ptr()->data()) +
+                                   byte_offset);
   }
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
   virtual uword ComputeCanonicalTableHash() const;
 
 #if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)
 #define TYPED_GETTER_SETTER(name, type)                                        \
   type Get##name(intptr_t byte_offset) const {                                 \
     NoSafepointScope no_safepoint;                                             \
     return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
@@ skipping 25 matching lines @@
   TYPED_GETTER_SETTER(Int64, int64_t)
   TYPED_GETTER_SETTER(Uint64, uint64_t)
   TYPED_GETTER_SETTER(Float32, float)
   TYPED_GETTER_SETTER(Float64, double)
   TYPED_GETTER_SETTER(Float32x4, simd128_value_t)
   TYPED_GETTER_SETTER(Int32x4, simd128_value_t)
   TYPED_GETTER_SETTER(Float64x2, simd128_value_t)
 
 #undef TYPED_GETTER_SETTER
 
-  static intptr_t length_offset() {
-    return OFFSET_OF(RawTypedData, length_);
-  }
+  static intptr_t length_offset() { return OFFSET_OF(RawTypedData, length_); }
 
   static intptr_t data_offset() {
     return OFFSET_OF_RETURNED_VALUE(RawTypedData, data);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypedData) ==
            OFFSET_OF_RETURNED_VALUE(RawTypedData, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t lengthInBytes) {
     ASSERT(0 <= lengthInBytes && lengthInBytes <= kSmiMax);
     return RoundedAllocationSize(sizeof(RawTypedData) + lengthInBytes);
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
     return element_size(ElementType(class_id));
   }
 
   static TypedDataElementType ElementType(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
-    return static_cast<TypedDataElementType>(
-        class_id - kTypedDataInt8ArrayCid);
+    return static_cast<TypedDataElementType>(class_id - kTypedDataInt8ArrayCid);
   }
 
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawTypedData* New(intptr_t class_id,
                            intptr_t len,
                            Heap::Space space = Heap::kNew);
 
   template <typename DstType, typename SrcType>
-  static void Copy(const DstType& dst, intptr_t dst_offset_in_bytes,
-                   const SrcType& src, intptr_t src_offset_in_bytes,
+  static void Copy(const DstType& dst,
+                   intptr_t dst_offset_in_bytes,
+                   const SrcType& src,
+                   intptr_t src_offset_in_bytes,
                    intptr_t length_in_bytes) {
-    ASSERT(Utils::RangeCheck(src_offset_in_bytes,
-                             length_in_bytes,
+    ASSERT(Utils::RangeCheck(src_offset_in_bytes, length_in_bytes,
                              src.LengthInBytes()));
-    ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
-                             length_in_bytes,
+    ASSERT(Utils::RangeCheck(dst_offset_in_bytes, length_in_bytes,
                              dst.LengthInBytes()));
     {
       NoSafepointScope no_safepoint;
       if (length_in_bytes > 0) {
         memmove(dst.DataAddr(dst_offset_in_bytes),
-                src.DataAddr(src_offset_in_bytes),
-                length_in_bytes);
+                src.DataAddr(src_offset_in_bytes), length_in_bytes);
       }
     }
   }
 
 
   template <typename DstType, typename SrcType>
-  static void ClampedCopy(const DstType& dst, intptr_t dst_offset_in_bytes,
-                          const SrcType& src, intptr_t src_offset_in_bytes,
+  static void ClampedCopy(const DstType& dst,
+                          intptr_t dst_offset_in_bytes,
+                          const SrcType& src,
+                          intptr_t src_offset_in_bytes,
                           intptr_t length_in_bytes) {
-    ASSERT(Utils::RangeCheck(src_offset_in_bytes,
-                             length_in_bytes,
+    ASSERT(Utils::RangeCheck(src_offset_in_bytes, length_in_bytes,
                              src.LengthInBytes()));
-    ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
-                             length_in_bytes,
+    ASSERT(Utils::RangeCheck(dst_offset_in_bytes, length_in_bytes,
                              dst.LengthInBytes()));
     {
       NoSafepointScope no_safepoint;
       if (length_in_bytes > 0) {
         uint8_t* dst_data =
             reinterpret_cast<uint8_t*>(dst.DataAddr(dst_offset_in_bytes));
         int8_t* src_data =
             reinterpret_cast<int8_t*>(src.DataAddr(src_offset_in_bytes));
         for (intptr_t ix = 0; ix < length_in_bytes; ix++) {
           int8_t v = *src_data;
@@ skipping 105 matching lines @@
     return RoundedAllocationSize(sizeof(RawExternalTypedData));
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
     return TypedData::element_size(ElementType(class_id));
   }
 
   static TypedDataElementType ElementType(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
-    return static_cast<TypedDataElementType>(
-        class_id - kExternalTypedDataInt8ArrayCid);
+    return static_cast<TypedDataElementType>(class_id -
+                                             kExternalTypedDataInt8ArrayCid);
   }
 
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawExternalTypedData* New(intptr_t class_id,
                                    uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
   static bool IsExternalTypedData(const Instance& obj) {
     ASSERT(!obj.IsNull());
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
  protected:
   void SetLength(intptr_t value) const {
     StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
   void SetData(uint8_t* data) const {
-    ASSERT(!Isolate::Current()->heap()->Contains(
-        reinterpret_cast<uword>(data)));
+    ASSERT(
+        !Isolate::Current()->heap()->Contains(reinterpret_cast<uword>(data)));
     StoreNonPointer(&raw_ptr()->data_, data);
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData, Instance);
   friend class Class;
 };
 
 
 class TypedDataView : public AllStatic {
  public:
   static intptr_t ElementSizeInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
     intptr_t cid = view_obj.raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawInstance* const*>(
-        view_obj.raw_ptr() + kDataOffset);
+    return *reinterpret_cast<RawInstance* const*>(view_obj.raw_ptr() +
+                                                  kDataOffset);
   }
 
   static RawSmi* OffsetInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawSmi* const*>(
-        view_obj.raw_ptr() + kOffsetInBytesOffset);
+    return *reinterpret_cast<RawSmi* const*>(view_obj.raw_ptr() +
+                                             kOffsetInBytesOffset);
   }
 
   static RawSmi* Length(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawSmi* const*>(
-        view_obj.raw_ptr() + kLengthOffset);
+    return *reinterpret_cast<RawSmi* const*>(view_obj.raw_ptr() +
+                                             kLengthOffset);
   }
 
   static bool IsExternalTypedDataView(const Instance& view_obj) {
     const Instance& data = Instance::Handle(Data(view_obj));
     intptr_t cid = data.raw()->GetClassId();
     ASSERT(RawObject::IsTypedDataClassId(cid) ||
            RawObject::IsExternalTypedDataClassId(cid));
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
-  static intptr_t NumberOfFields() {
-    return kLengthOffset;
-  }
+  static intptr_t NumberOfFields() { return kLengthOffset; }
 
-  static intptr_t data_offset() {
-    return kWordSize * kDataOffset;
-  }
+  static intptr_t data_offset() { return kWordSize * kDataOffset; }
 
   static intptr_t offset_in_bytes_offset() {
     return kWordSize * kOffsetInBytesOffset;
   }
 
-  static intptr_t length_offset() {
-    return kWordSize * kLengthOffset;
-  }
+  static intptr_t length_offset() { return kWordSize * kLengthOffset; }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataViewClassId(class_id));
-    return (class_id == kByteDataViewCid) ?
-        1 : TypedData::element_size(class_id - kTypedDataInt8ArrayViewCid);
+    return (class_id == kByteDataViewCid)
+               ? 1
+               : TypedData::element_size(class_id - kTypedDataInt8ArrayViewCid);
   }
 
  private:
   enum {
     kDataOffset = 1,
     kOffsetInBytesOffset = 2,
     kLengthOffset = 3,
   };
 };
 
 
 class ByteBuffer : public AllStatic {
  public:
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawInstance* const*>(
-        view_obj.raw_ptr() + kDataOffset);
+    return *reinterpret_cast<RawInstance* const*>(view_obj.raw_ptr() +
+                                                  kDataOffset);
   }
 
-  static intptr_t NumberOfFields() {
-    return kDataOffset;
-  }
+  static intptr_t NumberOfFields() { return kDataOffset; }
 
-  static intptr_t data_offset() {
-    return kWordSize * kDataOffset;
-  }
+  static intptr_t data_offset() { return kWordSize * kDataOffset; }
 
  private:
   enum {
     kDataOffset = 1,
   };
 };
 
 
 // Corresponds to
 // - "new Map()",
@@ skipping 22 matching lines @@
            ((value.Length() >= 2) &&
             value.IsInstantiated() /*&& value.IsCanonical()*/));
     // TODO(asiva): Values read from a message snapshot are not properly marked
     // as canonical. See for example tests/isolate/message3_test.dart.
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawLinkedHashMap, type_arguments_);
   }
 
-  RawTypedData* index() const {
-    return raw_ptr()->index_;
-  }
+  RawTypedData* index() const { return raw_ptr()->index_; }
   void SetIndex(const TypedData& value) const {
     StorePointer(&raw_ptr()->index_, value.raw());
   }
-  static intptr_t index_offset() {
-    return OFFSET_OF(RawLinkedHashMap, index_);
-  }
+  static intptr_t index_offset() { return OFFSET_OF(RawLinkedHashMap, index_); }
 
-  RawArray* data() const {
-    return raw_ptr()->data_;
-  }
+  RawArray* data() const { return raw_ptr()->data_; }
   void SetData(const Array& value) const {
     StorePointer(&raw_ptr()->data_, value.raw());
   }
-  static intptr_t data_offset() {
-    return OFFSET_OF(RawLinkedHashMap, data_);
-  }
+  static intptr_t data_offset() { return OFFSET_OF(RawLinkedHashMap, data_); }
 
-  RawSmi* hash_mask() const {
-    return raw_ptr()->hash_mask_;
-  }
+  RawSmi* hash_mask() const { return raw_ptr()->hash_mask_; }
   void SetHashMask(intptr_t value) const {
     StoreSmi(&raw_ptr()->hash_mask_, Smi::New(value));
   }
   static intptr_t hash_mask_offset() {
     return OFFSET_OF(RawLinkedHashMap, hash_mask_);
   }
 
-  RawSmi* used_data() const {
-    return raw_ptr()->used_data_;
-  }
+  RawSmi* used_data() const { return raw_ptr()->used_data_; }
   void SetUsedData(intptr_t value) const {
     StoreSmi(&raw_ptr()->used_data_, Smi::New(value));
   }
   static intptr_t used_data_offset() {
     return OFFSET_OF(RawLinkedHashMap, used_data_);
   }
 
-  RawSmi* deleted_keys() const {
-    return raw_ptr()->deleted_keys_;
-  }
+  RawSmi* deleted_keys() const { return raw_ptr()->deleted_keys_; }
   void SetDeletedKeys(intptr_t value) const {
     StoreSmi(&raw_ptr()->deleted_keys_, Smi::New(value));
   }
   static intptr_t deleted_keys_offset() {
     return OFFSET_OF(RawLinkedHashMap, deleted_keys_);
   }
 
   intptr_t Length() const {
     intptr_t used = Smi::Value(raw_ptr()->used_data_);
     intptr_t deleted = Smi::Value(raw_ptr()->deleted_keys_);
     return (used >> 1) - deleted;
   }
 
   // This iterator differs somewhat from its Dart counterpart (_CompactIterator
   // in runtime/lib/compact_hash.dart):
   //  - There are no checks for concurrent modifications.
   //  - Accessing a key or value before the first call to MoveNext and after
   //    MoveNext returns false will result in crashes.
   class Iterator : ValueObject {
    public:
     explicit Iterator(const LinkedHashMap& map)
-      : data_(Array::Handle(map.data())),
-        scratch_(Object::Handle()),
-        offset_(-2),
-        length_(Smi::Value(map.used_data())) {}
+        : data_(Array::Handle(map.data())),
+          scratch_(Object::Handle()),
+          offset_(-2),
+          length_(Smi::Value(map.used_data())) {}
 
     bool MoveNext() {
       while (true) {
         offset_ += 2;
         if (offset_ >= length_) {
           return false;
         }
         scratch_ = data_.At(offset_);
         if (scratch_.raw() != data_.raw()) {
           // Slot is not deleted (self-reference indicates deletion).
           return true;
         }
       }
     }
 
-    RawObject* CurrentKey() const {
-      return data_.At(offset_);
-    }
+    RawObject* CurrentKey() const { return data_.At(offset_); }
 
-    RawObject* CurrentValue() const {
-      return data_.At(offset_ + 1);
-    }
+    RawObject* CurrentValue() const { return data_.At(offset_ + 1); }
 
    private:
     const Array& data_;
     Object& scratch_;
     intptr_t offset_;
     const intptr_t length_;
   };
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap, Instance);
@@ skipping 96 matching lines @@
 
   Dart_Port origin_id() const { return raw_ptr()->origin_id_; }
   void set_origin_id(Dart_Port id) const {
     ASSERT(origin_id() == 0);
     StoreNonPointer(&(raw_ptr()->origin_id_), id);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSendPort));
   }
-  static RawSendPort* New(Dart_Port id,
-                          Heap::Space space = Heap::kNew);
+  static RawSendPort* New(Dart_Port id, Heap::Space space = Heap::kNew);
   static RawSendPort* New(Dart_Port id,
                           Dart_Port origin_id,
                           Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SendPort, Instance);
   friend class Class;
 };
 
 
@@ skipping 87 matching lines @@
                        : raw_ptr()->two_byte_bytecode_;
   }
 
   static intptr_t function_offset(intptr_t cid) {
     switch (cid) {
       case kOneByteStringCid:
         return OFFSET_OF(RawRegExp, one_byte_function_);
       case kTwoByteStringCid:
         return OFFSET_OF(RawRegExp, two_byte_function_);
       case kExternalOneByteStringCid:
-         return OFFSET_OF(RawRegExp, external_one_byte_function_);
+        return OFFSET_OF(RawRegExp, external_one_byte_function_);
       case kExternalTwoByteStringCid:
         return OFFSET_OF(RawRegExp, external_two_byte_function_);
     }
 
     UNREACHABLE();
     return -1;
   }
 
   RawFunction** FunctionAddr(intptr_t cid) const {
     return reinterpret_cast<RawFunction**>(
-          FieldAddrAtOffset(function_offset(cid)));
+        FieldAddrAtOffset(function_offset(cid)));
   }
 
-  RawFunction* function(intptr_t cid) const {
-    return *FunctionAddr(cid);
-  }
+  RawFunction* function(intptr_t cid) const { return *FunctionAddr(cid); }
 
   void set_pattern(const String& pattern) const;
   void set_function(intptr_t cid, const Function& value) const;
   void set_bytecode(bool is_one_byte, const TypedData& bytecode) const;
 
   void set_num_bracket_expressions(intptr_t value) const;
   void set_is_global() const { set_flags(flags() | kGlobal); }
   void set_is_ignore_case() const { set_flags(flags() | kIgnoreCase); }
   void set_is_multi_line() const { set_flags(flags() | kMultiLine); }
   void set_is_simple() const { set_type(kSimple); }
@@ skipping 17 matching lines @@
  private:
   void set_type(RegExType type) const {
     StoreNonPointer(&raw_ptr()->type_flags_,
                     TypeBits::update(type, raw_ptr()->type_flags_));
   }
   void set_flags(intptr_t value) const {
     StoreNonPointer(&raw_ptr()->type_flags_,
                     FlagsBits::update(value, raw_ptr()->type_flags_));
   }
 
-  RegExType type() const {
-    return TypeBits::decode(raw_ptr()->type_flags_);
-  }
-  intptr_t flags() const {
-    return FlagsBits::decode(raw_ptr()->type_flags_);
-  }
+  RegExType type() const { return TypeBits::decode(raw_ptr()->type_flags_); }
+  intptr_t flags() const { return FlagsBits::decode(raw_ptr()->type_flags_); }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(RegExp, Instance);
   friend class Class;
 };
 
 
 class WeakProperty : public Instance {
  public:
-  RawObject* key() const {
-    return raw_ptr()->key_;
-  }
+  RawObject* key() const { return raw_ptr()->key_; }
 
   void set_key(const Object& key) const {
     StorePointer(&raw_ptr()->key_, key.raw());
   }
 
-  RawObject* value() const {
-    return raw_ptr()->value_;
-  }
+  RawObject* value() const { return raw_ptr()->value_; }
 
   void set_value(const Object& value) const {
     StorePointer(&raw_ptr()->value_, value.raw());
   }
 
   static RawWeakProperty* New(Heap::Space space = Heap::kNew);
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawWeakProperty));
   }
 
   static void Clear(RawWeakProperty* raw_weak) {
     ASSERT(raw_weak->ptr()->next_ == 0);
     raw_weak->StorePointer(&(raw_weak->ptr()->key_), Object::null());
     raw_weak->StorePointer(&(raw_weak->ptr()->value_), Object::null());
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
   friend class Class;
 };
 
 
 class MirrorReference : public Instance {
  public:
-  RawObject* referent() const {
-    return raw_ptr()->referent_;
-  }
+  RawObject* referent() const { return raw_ptr()->referent_; }
 
   void set_referent(const Object& referent) const {
     StorePointer(&raw_ptr()->referent_, referent.raw());
   }
 
   RawAbstractType* GetAbstractTypeReferent() const;
 
   RawClass* GetClassReferent() const;
 
   RawField* GetFieldReferent() const;
@@ skipping 20 matching lines @@
 class UserTag : public Instance {
  public:
   uword tag() const { return raw_ptr()->tag(); }
   void set_tag(uword t) const {
     ASSERT(t >= UserTags::kUserTagIdOffset);
     ASSERT(t < UserTags::kUserTagIdOffset + UserTags::kMaxUserTags);
     StoreNonPointer(&raw_ptr()->tag_, t);
   }
   static intptr_t tag_offset() { return OFFSET_OF(RawUserTag, tag_); }
 
-  RawString* label() const {
-    return raw_ptr()->label_;
-  }
+  RawString* label() const { return raw_ptr()->label_; }
 
   void MakeActive() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUserTag));
   }
 
-  static RawUserTag* New(const String& label,
-                         Heap::Space space = Heap::kOld);
+  static RawUserTag* New(const String& label, Heap::Space space = Heap::kOld);
   static RawUserTag* DefaultTag();
 
   static bool TagTableIsFull(Thread* thread);
   static RawUserTag* FindTagById(uword tag_id);
 
  private:
   static RawUserTag* FindTagInIsolate(Thread* thread, const String& label);
   static void AddTagToIsolate(Thread* thread, const UserTag& tag);
 
   void set_label(const String& tag_label) const {
@@ skipping 216 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_