clang-format runtime/vm

runtime/vm/raw_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_RAW_OBJECT_H_
 #define RUNTIME_VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 27 matching lines @@
   V(LocalVarDescriptors)                                                       \
   V(ExceptionHandlers)                                                         \
   V(Context)                                                                   \
   V(ContextScope)                                                              \
   V(SingleTargetCache)                                                         \
   V(UnlinkedCall)                                                              \
   V(ICData)                                                                    \
   V(MegamorphicCache)                                                          \
   V(SubtypeTestCache)                                                          \
   V(Error)                                                                     \
-    V(ApiError)                                                                \
-    V(LanguageError)                                                           \
-    V(UnhandledException)                                                      \
-    V(UnwindError)                                                             \
+  V(ApiError)                                                                  \
+  V(LanguageError)                                                             \
+  V(UnhandledException)                                                        \
+  V(UnwindError)                                                               \
   V(Instance)                                                                  \
-    V(LibraryPrefix)                                                           \
-    V(AbstractType)                                                            \
-      V(Type)                                                                  \
-      V(TypeRef)                                                               \
-      V(TypeParameter)                                                         \
-      V(BoundedType)                                                           \
-      V(MixinAppType)                                                          \
-    V(Closure)                                                                 \
-    V(Number)                                                                  \
-      V(Integer)                                                               \
-        V(Smi)                                                                 \
-        V(Mint)                                                                \
-        V(Bigint)                                                              \
-      V(Double)                                                                \
-    V(Bool)                                                                    \
-    V(GrowableObjectArray)                                                     \
-    V(Float32x4)                                                               \
-    V(Int32x4)                                                                 \
-    V(Float64x2)                                                               \
-    V(TypedData)                                                               \
-    V(ExternalTypedData)                                                       \
-    V(Capability)                                                              \
-    V(ReceivePort)                                                             \
-    V(SendPort)                                                                \
-    V(Stacktrace)                                                              \
-    V(RegExp)                                                                  \
-    V(WeakProperty)                                                            \
-    V(MirrorReference)                                                         \
-    V(LinkedHashMap)                                                           \
-    V(UserTag)                                                                 \
+  V(LibraryPrefix)                                                             \
+  V(AbstractType)                                                              \
+  V(Type)                                                                      \
+  V(TypeRef)                                                                   \
+  V(TypeParameter)                                                             \
+  V(BoundedType)                                                               \
+  V(MixinAppType)                                                              \
+  V(Closure)                                                                   \
+  V(Number)                                                                    \
+  V(Integer)                                                                   \
+  V(Smi)                                                                       \
+  V(Mint)                                                                      \
+  V(Bigint)                                                                    \
+  V(Double)                                                                    \
+  V(Bool)                                                                      \
+  V(GrowableObjectArray)                                                       \
+  V(Float32x4)                                                                 \
+  V(Int32x4)                                                                   \
+  V(Float64x2)                                                                 \
+  V(TypedData)                                                                 \
+  V(ExternalTypedData)                                                         \
+  V(Capability)                                                                \
+  V(ReceivePort)                                                               \
+  V(SendPort)                                                                  \
+  V(Stacktrace)                                                                \
+  V(RegExp)                                                                    \
+  V(WeakProperty)                                                              \
+  V(MirrorReference)                                                           \
+  V(LinkedHashMap)                                                             \
+  V(UserTag)
 
 #define CLASS_LIST_ARRAYS(V)                                                   \
   V(Array)                                                                     \
-    V(ImmutableArray)                                                          \
+  V(ImmutableArray)
 
 #define CLASS_LIST_STRINGS(V)                                                  \
   V(String)                                                                    \
-    V(OneByteString)                                                           \
-    V(TwoByteString)                                                           \
-    V(ExternalOneByteString)                                                   \
-    V(ExternalTwoByteString)
+  V(OneByteString)                                                             \
+  V(TwoByteString)                                                             \
+  V(ExternalOneByteString)                                                     \
+  V(ExternalTwoByteString)
 
 #define CLASS_LIST_TYPED_DATA(V)                                               \
   V(Int8Array)                                                                 \
   V(Uint8Array)                                                                \
   V(Uint8ClampedArray)                                                         \
   V(Int16Array)                                                                \
   V(Uint16Array)                                                               \
   V(Int32Array)                                                                \
   V(Uint32Array)                                                               \
   V(Int64Array)                                                                \
   V(Uint64Array)                                                               \
   V(Float32Array)                                                              \
   V(Float64Array)                                                              \
   V(Float32x4Array)                                                            \
   V(Int32x4Array)                                                              \
-  V(Float64x2Array)                                                            \
+  V(Float64x2Array)
 
 #define DART_CLASS_LIST_TYPED_DATA(V)                                          \
   V(Int8)                                                                      \
   V(Uint8)                                                                     \
   V(Uint8Clamped)                                                              \
   V(Int16)                                                                     \
   V(Uint16)                                                                    \
   V(Int32)                                                                     \
   V(Uint32)                                                                    \
   V(Int64)                                                                     \
@@ skipping 14 matching lines @@
   CLASS_LIST_ARRAYS(V)                                                         \
   CLASS_LIST_STRINGS(V)
 
 #define CLASS_LIST(V)                                                          \
   V(Object)                                                                    \
   CLASS_LIST_NO_OBJECT(V)
 
 
 // Forward declarations.
 class Isolate;
-#define DEFINE_FORWARD_DECLARATION(clazz)                                      \
-  class Raw##clazz;
+#define DEFINE_FORWARD_DECLARATION(clazz) class Raw##clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 
 
 enum ClassId {
   // Illegal class id.
   kIllegalCid = 0,
 
   // The following entries describes classes for pseudo-objects in the heap
   // that should never be reachable from live objects. Free list elements
   // maintain the free list for old space, and forwarding corpses are used to
   // implement one-way become.
   kFreeListElement,
   kForwardingCorpse,
 
-  // List of Ids for predefined classes.
-#define DEFINE_OBJECT_KIND(clazz)                                              \
-  k##clazz##Cid,
-CLASS_LIST(DEFINE_OBJECT_KIND)
+// List of Ids for predefined classes.
+#define DEFINE_OBJECT_KIND(clazz) k##clazz##Cid,
+  CLASS_LIST(DEFINE_OBJECT_KIND)
 #undef DEFINE_OBJECT_KIND
 
-#define DEFINE_OBJECT_KIND(clazz)                                              \
-  kTypedData##clazz##Cid,
-CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
+#define DEFINE_OBJECT_KIND(clazz) kTypedData##clazz##Cid,
+      CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
 #undef DEFINE_OBJECT_KIND
 
-#define DEFINE_OBJECT_KIND(clazz)                                              \
-  kTypedData##clazz##ViewCid,
-CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
+#define DEFINE_OBJECT_KIND(clazz) kTypedData##clazz##ViewCid,
+          CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
 #undef DEFINE_OBJECT_KIND
 
-  kByteDataViewCid,
+              kByteDataViewCid,
 
-#define DEFINE_OBJECT_KIND(clazz)                                              \
-  kExternalTypedData##clazz##Cid,
-CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
+#define DEFINE_OBJECT_KIND(clazz) kExternalTypedData##clazz##Cid,
+  CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
 #undef DEFINE_OBJECT_KIND
 
-  kByteBufferCid,
+      kByteBufferCid,
 
   // The following entries do not describe a predefined class, but instead
   // are class indexes for pre-allocated instance (Null, dynamic and Void).
   kNullCid,
   kDynamicCid,
   kVoidCid,
 
   kNumPredefinedCids,
 };
 
@@ skipping 10 matching lines @@
 enum {
   kSmiTag = 0,
   kHeapObjectTag = 1,
   kSmiTagSize = 1,
   kSmiTagMask = 1,
   kSmiTagShift = 1,
 };
 
 enum TypedDataElementType {
 #define V(name) k##name##Element,
-CLASS_LIST_TYPED_DATA(V)
+  CLASS_LIST_TYPED_DATA(V)
 #undef V
 };
 
 #define SNAPSHOT_WRITER_SUPPORT()                                              \
-  void WriteTo(                                                                \
-      SnapshotWriter* writer, intptr_t object_id,                              \
-      Snapshot::Kind kind, bool as_reference);                                 \
-  friend class SnapshotWriter;                                                 \
+  void WriteTo(SnapshotWriter* writer, intptr_t object_id,                     \
+               Snapshot::Kind kind, bool as_reference);                        \
+  friend class SnapshotWriter;
 
 #define VISITOR_SUPPORT(object)                                                \
   static intptr_t Visit##object##Pointers(Raw##object* raw_obj,                \
                                           ObjectPointerVisitor* visitor);
 
-#define HEAP_PROFILER_SUPPORT()                                                \
-  friend class HeapProfiler;                                                   \
+#define HEAP_PROFILER_SUPPORT() friend class HeapProfiler;
 
 #define RAW_OBJECT_IMPLEMENTATION(object)                                      \
- private:  /* NOLINT */                                                        \
+ private: /* NOLINT */                                                         \
   VISITOR_SUPPORT(object)                                                      \
   friend class object;                                                         \
   friend class RawObject;                                                      \
   friend class Heap;                                                           \
   friend class Simulator;                                                      \
   friend class SimulatorHelpers;                                               \
   DISALLOW_ALLOCATION();                                                       \
   DISALLOW_IMPLICIT_CONSTRUCTORS(Raw##object)
 
 // TODO(koda): Make ptr() return const*, like Object::raw_ptr().
 #define RAW_HEAP_OBJECT_IMPLEMENTATION(object)                                 \
-  private:                                                                     \
-    RAW_OBJECT_IMPLEMENTATION(object);                                         \
-    Raw##object* ptr() const {                                                 \
-      ASSERT(IsHeapObject());                                                  \
-      return reinterpret_cast<Raw##object*>(                                   \
-          reinterpret_cast<uword>(this) - kHeapObjectTag);                     \
-    }                                                                          \
-    SNAPSHOT_WRITER_SUPPORT()                                                  \
-    HEAP_PROFILER_SUPPORT()                                                    \
-    friend class object##SerializationCluster;                                 \
-    friend class object##DeserializationCluster;                               \
+ private:                                                                      \
+  RAW_OBJECT_IMPLEMENTATION(object);                                           \
+  Raw##object* ptr() const {                                                   \
+    ASSERT(IsHeapObject());                                                    \
+    return reinterpret_cast<Raw##object*>(reinterpret_cast<uword>(this) -      \
+                                          kHeapObjectTag);                     \
+  }                                                                            \
+  SNAPSHOT_WRITER_SUPPORT()                                                    \
+  HEAP_PROFILER_SUPPORT()                                                      \
+  friend class object##SerializationCluster;                                   \
+  friend class object##DeserializationCluster;
 
 // RawObject is the base class of all raw objects; even though it carries the
 // tags_ field not all raw objects are allocated in the heap and thus cannot
 // be dereferenced (e.g. RawSmi).
 class RawObject {
  public:
   // The tags field which is a part of the object header uses the following
   // bit fields for storing tags.
   enum TagBits {
     kMarkBit = 0,
@@ skipping 16 matching lines @@
 #else
 #error Unexpected architecture word size
 #endif
   };
 
   COMPILE_ASSERT(kClassIdTagSize == (sizeof(classid_t) * kBitsPerByte));
 
   // Encodes the object size in the tag in units of object alignment.
   class SizeTag {
    public:
-    static const intptr_t kMaxSizeTag =
-        ((1 << RawObject::kSizeTagSize) - 1) << kObjectAlignmentLog2;
+    static const intptr_t kMaxSizeTag = ((1 << RawObject::kSizeTagSize) - 1)
+                                        << kObjectAlignmentLog2;
 
     static uword encode(intptr_t size) {
       return SizeBits::encode(SizeToTagValue(size));
     }
 
     static intptr_t decode(uword tag) {
       return TagValueToSize(SizeBits::decode(tag));
     }
 
     static uword update(intptr_t size, uword tag) {
       return SizeBits::update(SizeToTagValue(size), tag);
     }
 
    private:
     // The actual unscaled bit field used within the tag field.
-    class SizeBits :
-        public BitField<uword, intptr_t, kSizeTagPos, kSizeTagSize> {};
+    class SizeBits
+        : public BitField<uword, intptr_t, kSizeTagPos, kSizeTagSize> {};
 
     static intptr_t SizeToTagValue(intptr_t size) {
       ASSERT(Utils::IsAligned(size, kObjectAlignment));
-      return  (size > kMaxSizeTag) ? 0 : (size >> kObjectAlignmentLog2);
+      return (size > kMaxSizeTag) ? 0 : (size >> kObjectAlignmentLog2);
     }
     static intptr_t TagValueToSize(intptr_t value) {
       return value << kObjectAlignmentLog2;
     }
   };
 
-  class ClassIdTag :
-      public BitField<uword, intptr_t, kClassIdTagPos, kClassIdTagSize> {};
+  class ClassIdTag
+      : public BitField<uword, intptr_t, kClassIdTagPos, kClassIdTagSize> {};
 
   bool IsWellFormed() const {
     uword value = reinterpret_cast<uword>(this);
     return (value & kSmiTagMask) == 0 ||
-        Utils::IsAligned(value - kHeapObjectTag, kWordSize);
+           Utils::IsAligned(value - kHeapObjectTag, kWordSize);
   }
   bool IsHeapObject() const {
     ASSERT(IsWellFormed());
     uword value = reinterpret_cast<uword>(this);
     return (value & kSmiTagMask) == kHeapObjectTag;
   }
   // Assumes this is a heap object.
   bool IsNewObject() const {
     ASSERT(IsHeapObject());
     uword addr = reinterpret_cast<uword>(this);
@@ skipping 11 matching lines @@
     ASSERT(IsWellFormed());
     COMPILE_ASSERT(kHeapObjectTag == 1);
     COMPILE_ASSERT(kNewObjectAlignmentOffset == kWordSize);
     static const uword kNewObjectBits =
         (kNewObjectAlignmentOffset | kHeapObjectTag);
     const uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectBits) != kNewObjectBits;
   }
 
   // Support for GC marking bit.
-  bool IsMarked() const {
-    return MarkBit::decode(ptr()->tags_);
-  }
+  bool IsMarked() const { return MarkBit::decode(ptr()->tags_); }
   void SetMarkBit() {
     ASSERT(!IsMarked());
     UpdateTagBit<MarkBit>(true);
   }
   void SetMarkBitUnsynchronized() {
     ASSERT(!IsMarked());
     uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(true, tags);
   }
   void ClearMarkBit() {
     ASSERT(IsMarked());
     UpdateTagBit<MarkBit>(false);
   }
   // Returns false if the bit was already set.
   // TODO(koda): Add "must use result" annotation here, after we add support.
-  bool TryAcquireMarkBit() {
-    return TryAcquireTagBit<MarkBit>();
-  }
+  bool TryAcquireMarkBit() { return TryAcquireTagBit<MarkBit>(); }
 
   // Support for object tags.
-  bool IsCanonical() const {
-    return CanonicalObjectTag::decode(ptr()->tags_);
-  }
-  void SetCanonical() {
-    UpdateTagBit<CanonicalObjectTag>(true);
-  }
-  void ClearCanonical() {
-    UpdateTagBit<CanonicalObjectTag>(false);
-  }
-  bool IsVMHeapObject() const {
-    return VMHeapObjectTag::decode(ptr()->tags_);
-  }
-  void SetVMHeapObject() {
-    UpdateTagBit<VMHeapObjectTag>(true);
-  }
+  bool IsCanonical() const { return CanonicalObjectTag::decode(ptr()->tags_); }
+  void SetCanonical() { UpdateTagBit<CanonicalObjectTag>(true); }
+  void ClearCanonical() { UpdateTagBit<CanonicalObjectTag>(false); }
+  bool IsVMHeapObject() const { return VMHeapObjectTag::decode(ptr()->tags_); }
+  void SetVMHeapObject() { UpdateTagBit<VMHeapObjectTag>(true); }
 
   // Support for GC remembered bit.
-  bool IsRemembered() const {
-    return RememberedBit::decode(ptr()->tags_);
-  }
+  bool IsRemembered() const { return RememberedBit::decode(ptr()->tags_); }
   void SetRememberedBit() {
     ASSERT(!IsRemembered());
     UpdateTagBit<RememberedBit>(true);
   }
   void SetRememberedBitUnsynchronized() {
     ASSERT(!IsRemembered());
     uword tags = ptr()->tags_;
     ptr()->tags_ = RememberedBit::update(true, tags);
   }
-  void ClearRememberedBit() {
-    UpdateTagBit<RememberedBit>(false);
-  }
+  void ClearRememberedBit() { UpdateTagBit<RememberedBit>(false); }
   void ClearRememberedBitUnsynchronized() {
     uword tags = ptr()->tags_;
     ptr()->tags_ = RememberedBit::update(false, tags);
   }
   // Returns false if the bit was already set.
   // TODO(koda): Add "must use result" annotation here, after we add support.
-  bool TryAcquireRememberedBit() {
-    return TryAcquireTagBit<RememberedBit>();
-  }
+  bool TryAcquireRememberedBit() { return TryAcquireTagBit<RememberedBit>(); }
 
 #define DEFINE_IS_CID(clazz)                                                   \
   bool Is##clazz() const { return ((GetClassId() == k##clazz##Cid)); }
-CLASS_LIST(DEFINE_IS_CID)
+  CLASS_LIST(DEFINE_IS_CID)
 #undef DEFINE_IS_CID
 
 #define DEFINE_IS_CID(clazz)                                                   \
   bool IsTypedData##clazz() const {                                            \
     return ((GetClassId() == kTypedData##clazz##Cid));                         \
   }                                                                            \
   bool IsTypedDataView##clazz() const {                                        \
     return ((GetClassId() == kTypedData##clazz##ViewCid));                     \
   }                                                                            \
   bool IsExternalTypedData##clazz() const {                                    \
     return ((GetClassId() == kExternalTypedData##clazz##Cid));                 \
   }
-CLASS_LIST_TYPED_DATA(DEFINE_IS_CID)
+  CLASS_LIST_TYPED_DATA(DEFINE_IS_CID)
 #undef DEFINE_IS_CID
 
-  bool IsStringInstance() const {
-    return IsStringClassId(GetClassId());
-  }
+  bool IsStringInstance() const { return IsStringClassId(GetClassId()); }
   bool IsDartInstance() const {
     return (!IsHeapObject() || (GetClassId() >= kInstanceCid));
   }
   bool IsFreeListElement() const {
     return ((GetClassId() == kFreeListElement));
   }
   bool IsForwardingCorpse() const {
     return ((GetClassId() == kForwardingCorpse));
   }
   bool IsPseudoObject() const {
@@ skipping 62 matching lines @@
   uword tags_;  // Various object tags (bits).
 
   class MarkBit : public BitField<uword, bool, kMarkBit, 1> {};
 
   class RememberedBit : public BitField<uword, bool, kRememberedBit, 1> {};
 
   class CanonicalObjectTag : public BitField<uword, bool, kCanonicalBit, 1> {};
 
   class VMHeapObjectTag : public BitField<uword, bool, kVMHeapObjectBit, 1> {};
 
-  class ReservedBits : public
-      BitField<uword, intptr_t, kReservedTagPos, kReservedTagSize> {};
+  class ReservedBits
+      : public BitField<uword, intptr_t, kReservedTagPos, kReservedTagSize> {};
 
   // TODO(koda): After handling tags_, return const*, like Object::raw_ptr().
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
-    return reinterpret_cast<RawObject*>(
-        reinterpret_cast<uword>(this) - kHeapObjectTag);
+    return reinterpret_cast<RawObject*>(reinterpret_cast<uword>(this) -
+                                        kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
   intptr_t GetClassId() const {
     uword tags = ptr()->tags_;
     return ClassIdTag::decode(tags);
   }
 
   void SetClassId(intptr_t new_cid) {
     uword tags = ptr()->tags_;
     ptr()->tags_ = ClassIdTag::update(new_cid, tags);
   }
 
-  template<class TagBitField>
+  template <class TagBitField>
   void UpdateTagBit(bool value) {
     uword tags = ptr()->tags_;
     uword old_tags;
     do {
       old_tags = tags;
       uword new_tags = TagBitField::update(value, old_tags);
-      tags = AtomicOperations::CompareAndSwapWord(
-          &ptr()->tags_, old_tags, new_tags);
+      tags = AtomicOperations::CompareAndSwapWord(&ptr()->tags_, old_tags,
+                                                  new_tags);
     } while (tags != old_tags);
   }
 
-  template<class TagBitField>
+  template <class TagBitField>
   bool TryAcquireTagBit() {
     uword tags = ptr()->tags_;
     uword old_tags;
     do {
       old_tags = tags;
       if (TagBitField::decode(tags)) return false;
       uword new_tags = TagBitField::update(true, old_tags);
-      tags = AtomicOperations::CompareAndSwapWord(
-          &ptr()->tags_, old_tags, new_tags);
+      tags = AtomicOperations::CompareAndSwapWord(&ptr()->tags_, old_tags,
+                                                  new_tags);
     } while (tags != old_tags);
     return true;
   }
 
   // All writes to heap objects should ultimately pass through one of the
   // methods below or their counterparts in Object, to ensure that the
   // write barrier is correctly applied.
 
-  template<typename type>
+  template <typename type>
   void StorePointer(type const* addr, type value) {
     *const_cast<type*>(addr) = value;
     // Filter stores based on source and target.
     if (!value->IsHeapObject()) return;
-    if (value->IsNewObject() && this->IsOldObject() &&
-        !this->IsRemembered()) {
+    if (value->IsNewObject() && this->IsOldObject() && !this->IsRemembered()) {
       this->SetRememberedBit();
       Thread::Current()->StoreBufferAddObject(this);
     }
   }
 
   // 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) {
     // Can't use Contains, as array length is initialized through this method.
     ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(this));
     *const_cast<RawSmi**>(addr) = value;
   }
 
   friend class Api;
   friend class ApiMessageReader;  // GetClassId
-  friend class Serializer;  // GetClassId
+  friend class Serializer;        // GetClassId
   friend class Array;
   friend class Become;  // GetClassId
   friend class Bigint;
   friend class ByteBuffer;
   friend class CidRewriteVisitor;
   friend class Closure;
   friend class Code;
   friend class Double;
   friend class ForwardPointersVisitor;  // StorePointer
   friend class FreeListElement;
   friend class Function;
   friend class GCMarker;
   friend class ExternalTypedData;
   friend class ForwardList;
   friend class GrowableObjectArray;  // StorePointer
   friend class Heap;
   friend class HeapMapAsJSONVisitor;
   friend class ClassStatsVisitor;
-  template<bool> friend class MarkingVisitorBase;
+  template <bool>
+  friend class MarkingVisitorBase;
   friend class Mint;
   friend class Object;
   friend class OneByteString;  // StoreSmi
   friend class RawCode;
   friend class RawExternalTypedData;
   friend class RawInstructions;
   friend class RawInstance;
   friend class RawTypedData;
   friend class Scavenger;
   friend class ScavengerVisitor;
   friend class SizeExcludingClassVisitor;  // GetClassId
-  friend class InstanceAccumulator;  // GetClassId
-  friend class RetainingPathVisitor;  // GetClassId
-  friend class SkippedCodeFunctions;  // StorePointer
-  friend class InstructionsReader;  // tags_ check
+  friend class InstanceAccumulator;        // GetClassId
+  friend class RetainingPathVisitor;       // GetClassId
+  friend class SkippedCodeFunctions;       // StorePointer
+  friend class InstructionsReader;         // tags_ check
   friend class AssemblyInstructionsWriter;
   friend class BlobInstructionsWriter;
   friend class SnapshotReader;
   friend class Deserializer;
   friend class SnapshotWriter;
   friend class String;
   friend class Type;  // GetClassId
   friend class TypedData;
   friend class TypedDataView;
-  friend class WeakProperty;  // StorePointer
-  friend class Instance;  // StorePointer
-  friend class StackFrame;  // GetCodeObject assertion.
+  friend class WeakProperty;            // StorePointer
+  friend class Instance;                // StorePointer
+  friend class StackFrame;              // GetCodeObject assertion.
   friend class CodeLookupTableBuilder;  // profiler
-  friend class NativeEntry;  // GetClassId
+  friend class NativeEntry;             // GetClassId
   friend class Simulator;
   friend class SimulatorHelpers;
   friend class ObjectLocator;
   friend class InstanceMorpher;  // GetClassId
   friend class VerifyCanonicalVisitor;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(RawObject);
 };
 
 
 class RawClass : public RawObject {
  public:
   enum ClassFinalizedState {
-    kAllocated = 0,  // Initial state.
-    kPreFinalized,  // VM classes: size precomputed, but no checks done.
-    kFinalized,  // Class parsed, finalized and ready for use.
+    kAllocated = 0,         // Initial state.
+    kPreFinalized,          // VM classes: size precomputed, but no checks done.
+    kFinalized,             // Class parsed, finalized and ready for use.
     kRefinalizeAfterPatch,  // Class needs to be refinalized (patched).
   };
 
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(Class);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   NOT_IN_PRODUCT(RawString* user_name_);
   RawArray* functions_;
   RawArray* functions_hash_table_;
   RawArray* fields_;
   RawArray* offset_in_words_to_field_;
   RawArray* interfaces_;  // Array of AbstractType.
   RawScript* script_;
   RawLibrary* library_;
   RawTypeArguments* type_parameters_;  // Array of TypeParameter.
   RawAbstractType* super_type_;
   RawType* mixin_;  // Generic mixin type, e.g. M<T>, not M<int>.
   RawFunction* signature_function_;  // Associated function for typedef class.
-  RawArray* constants_;  // Canonicalized const instances of this class.
+  RawArray* constants_;      // Canonicalized const instances of this class.
   RawType* canonical_type_;  // Canonical type for this class.
   RawArray* invocation_dispatcher_cache_;  // Cache for dispatcher functions.
   RawCode* allocation_stub_;  // Stub code for allocation of instances.
   RawGrowableObjectArray* direct_subclasses_;  // Array of Class.
-  RawArray* dependent_code_;  // CHA optimized codes.
+  RawArray* dependent_code_;                   // CHA optimized codes.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->dependent_code_);
   }
   RawObject** to_snapshot(Snapshot::Kind kind) {
     switch (kind) {
       case Snapshot::kCore:
       case Snapshot::kScript:
       case Snapshot::kAppWithJIT:
       case Snapshot::kAppNoJIT:
         return reinterpret_cast<RawObject**>(&ptr()->direct_subclasses_);
       case Snapshot::kMessage:
       case Snapshot::kNone:
       case Snapshot::kInvalid:
         break;
     }
     UNREACHABLE();
     return NULL;
   }
 
   cpp_vtable handle_vtable_;
   TokenPosition token_pos_;
   int32_t instance_size_in_words_;  // Size if fixed len or 0 if variable len.
   int32_t type_arguments_field_offset_in_words_;  // Offset of type args fld.
   int32_t next_field_offset_in_words_;  // Offset of the next instance field.
-  classid_t id_;  // Class Id, also index in the class table.
+  classid_t id_;                // Class Id, also index in the class table.
   int16_t num_type_arguments_;  // Number of type arguments in flattened vector.
   int16_t num_own_type_arguments_;  // Number of non-overlapping type arguments.
-  uint16_t num_native_fields_;  // Number of native fields in class.
+  uint16_t num_native_fields_;      // Number of native fields in class.
   uint16_t state_bits_;
 
   friend class Instance;
   friend class Isolate;
   friend class Object;
   friend class RawInstance;
   friend class RawInstructions;
   friend class SnapshotReader;
   friend class InstanceSerializationCluster;
   friend class CidRewriteVisitor;
 };
 
 
 class RawUnresolvedClass : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_prefix_);
   }
   RawLibraryPrefix* library_prefix_;  // Library prefix qualifier for the ident.
-  RawString* ident_;  // Name of the unresolved identifier.
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->ident_);
-  }
+  RawString* ident_;                  // Name of the unresolved identifier.
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->ident_); }
   TokenPosition token_pos_;
 };
 
 
 class RawTypeArguments : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->instantiations_);
@@ skipping 25 matching lines @@
 class RawPatchClass : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(PatchClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->patched_class_);
   }
   RawClass* patched_class_;
   RawClass* origin_class_;
   RawScript* script_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->script_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->script_); }
 
   friend class Function;
 };
 
 
 class RawFunction : public RawObject {
  public:
   enum Kind {
     kRegularFunction,
     kClosureFunction,
     kSignatureFunction,  // represents a signature only without actual code.
     kGetterFunction,     // represents getter functions e.g: get foo() { .. }.
     kSetterFunction,     // represents setter functions e.g: set foo(..) { .. }.
     kConstructor,
-    kImplicitGetter,     // represents an implicit getter for fields.
-    kImplicitSetter,     // represents an implicit setter for fields.
+    kImplicitGetter,             // represents an implicit getter for fields.
+    kImplicitSetter,             // represents an implicit setter for fields.
     kImplicitStaticFinalGetter,  // represents an implicit getter for static
                                  // final fields (incl. static const fields).
     kMethodExtractor,  // converts method into implicit closure on the receiver.
     kNoSuchMethodDispatcher,  // invokes noSuchMethod.
-    kInvokeFieldDispatcher,  // invokes a field as a closure.
-    kIrregexpFunction,   // represents a generated irregexp matcher function.
+    kInvokeFieldDispatcher,   // invokes a field as a closure.
+    kIrregexpFunction,  // represents a generated irregexp matcher function.
   };
 
   enum AsyncModifier {
     kNoModifier = 0x0,
-    kAsyncBit   = 0x1,
-    kGeneratorBit =  0x2,
-    kAsync      = kAsyncBit,
-    kSyncGen    = kGeneratorBit,
-    kAsyncGen   = kAsyncBit | kGeneratorBit,
+    kAsyncBit = 0x1,
+    kGeneratorBit = 0x2,
+    kAsync = kAsyncBit,
+    kSyncGen = kGeneratorBit,
+    kAsyncGen = kAsyncBit | kGeneratorBit,
   };
 
  private:
   // So that the SkippedCodeFunctions::DetachCode can null out the code fields.
   friend class SkippedCodeFunctions;
   friend class Class;
 
   RAW_HEAP_OBJECT_IMPLEMENTATION(Function);
 
   static bool ShouldVisitCode(RawCode* raw_code);
@@ skipping 25 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->code_);
 #else
     return reinterpret_cast<RawObject**>(&ptr()->unoptimized_code_);
 #endif
   }
 
   NOT_IN_PRECOMPILED(TokenPosition token_pos_);
   NOT_IN_PRECOMPILED(TokenPosition end_token_pos_);
   NOT_IN_PRECOMPILED(int32_t usage_counter_);  // Accessed from generated code
                                                // (JIT only).
-  uint32_t kind_tag_;  // See Function::KindTagBits.
+  uint32_t kind_tag_;                          // See Function::KindTagBits.
   int16_t num_fixed_parameters_;
   int16_t num_optional_parameters_;  // > 0: positional; < 0: named.
   NOT_IN_PRECOMPILED(void* kernel_function_);
   NOT_IN_PRECOMPILED(uint16_t optimized_instruction_count_);
   NOT_IN_PRECOMPILED(uint16_t optimized_call_site_count_);
   NOT_IN_PRECOMPILED(int8_t deoptimization_counter_);
   NOT_IN_PRECOMPILED(int8_t was_compiled_);
 };
 
 
 class RawClosureData : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(ClosureData);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->context_scope_);
   }
   RawContextScope* context_scope_;
   RawFunction* parent_function_;  // Enclosing function of this local function.
   RawType* signature_type_;
   RawInstance* closure_;  // Closure object for static implicit closures.
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->closure_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->closure_); }
 
   friend class Function;
 };
 
 
 class RawRedirectionData : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(RedirectionData);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->type_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
   RawType* type_;
   RawString* identifier_;
   RawFunction* target_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->target_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->target_); }
 };
 
 
 class RawField : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Field);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawObject* owner_;  // Class or patch class or mixin class
                       // where this field is defined or original field.
   RawAbstractType* type_;
   union {
     RawInstance* static_value_;  // Value for static fields.
-    RawSmi* offset_;  // Offset in words for instance fields.
+    RawSmi* offset_;             // Offset in words for instance fields.
   } value_;
   union {
     // When precompiling we need to save the static initializer function here
     // so that code for it can be generated.
     RawFunction* precompiled_;  // Static initializer function - precompiling.
     // When generating script snapshots after running the application it is
     // necessary to save the initial value of static fields so that we can
     // restore the value back to the original initial value.
     RawInstance* saved_value_;  // Saved initial value - static fields.
   } initializer_;
@@ skipping 32 matching lines @@
   uint8_t kind_bits_;  // static, final, const, has initializer....
   NOT_IN_PRECOMPILED(void* kernel_field_);
 
   friend class CidRewriteVisitor;
 };
 
 
 class RawLiteralToken : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LiteralToken);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->literal_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->literal_); }
   RawString* literal_;  // Literal characters as they appear in source text.
-  RawObject* value_;  // The actual object corresponding to the token.
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->value_);
-  }
+  RawObject* value_;    // The actual object corresponding to the token.
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->value_); }
   Token::Kind kind_;  // The literal kind (string, integer, double).
 
   friend class SnapshotReader;
 };
 
 
 class RawTokenStream : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TokenStream);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->private_key_);
   }
   RawString* private_key_;  // Key used for private identifiers.
   RawGrowableObjectArray* token_objects_;
   RawExternalTypedData* stream_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->stream_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->stream_); }
 
   friend class SnapshotReader;
 };
 
 
 class RawScript : public RawObject {
  public:
   enum Kind {
     kScriptTag = 0,
     kLibraryTag,
     kSourceTag,
     kPatchTag,
     kEvaluateTag,
   };
 
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(Script);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->url_); }
   RawString* url_;
   RawString* resolved_url_;
   RawArray* compile_time_constants_;
   RawTokenStream* tokens_;
   RawString* source_;
-  RawObject** to() {return reinterpret_cast<RawObject**>(&ptr()->source_); }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->source_); }
   RawObject** to_snapshot(Snapshot::Kind kind) {
     switch (kind) {
       case Snapshot::kAppNoJIT:
         return reinterpret_cast<RawObject**>(&ptr()->url_);
       case Snapshot::kCore:
       case Snapshot::kAppWithJIT:
       case Snapshot::kScript:
         return reinterpret_cast<RawObject**>(&ptr()->tokens_);
       case Snapshot::kMessage:
       case Snapshot::kNone:
@@ skipping 19 matching lines @@
     kLoaded,          // Library is loaded.
     kLoadError,       // Error occurred during load of the Library.
   };
 
   RAW_HEAP_OBJECT_IMPLEMENTATION(Library);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawString* url_;
   RawString* private_key_;
-  RawArray* dictionary_;         // Top-level names in this library.
+  RawArray* dictionary_;              // Top-level names in this library.
   RawGrowableObjectArray* metadata_;  // Metadata on classes, methods etc.
-  RawClass* toplevel_class_;     // Class containing top-level elements.
+  RawClass* toplevel_class_;          // Class containing top-level elements.
   RawGrowableObjectArray* patch_classes_;
-  RawArray* imports_;            // List of Namespaces imported without prefix.
-  RawArray* exports_;            // List of re-exported Namespaces.
-  RawInstance* load_error_;      // Error iff load_state_ == kLoadError.
+  RawArray* imports_;        // List of Namespaces imported without prefix.
+  RawArray* exports_;        // List of re-exported Namespaces.
+  RawInstance* load_error_;  // Error iff load_state_ == kLoadError.
   RawObject** to_snapshot() {
     return reinterpret_cast<RawObject**>(&ptr()->load_error_);
   }
-  RawArray* resolved_names_;     // Cache of resolved names in library scope.
-  RawArray* exported_names_;     // Cache of exported names by library.
-  RawArray* loaded_scripts_;     // Array of scripts loaded in this library.
+  RawArray* resolved_names_;  // Cache of resolved names in library scope.
+  RawArray* exported_names_;  // Cache of exported names by library.
+  RawArray* loaded_scripts_;  // Array of scripts loaded in this library.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->loaded_scripts_);
   }
 
   Dart_NativeEntryResolver native_entry_resolver_;  // Resolves natives.
   Dart_NativeEntrySymbol native_entry_symbol_resolver_;
-  classid_t index_;              // Library id number.
-  uint16_t num_imports_;         // Number of entries in imports_.
-  int8_t load_state_;            // Of type LibraryState.
+  classid_t index_;       // Library id number.
+  uint16_t num_imports_;  // Number of entries in imports_.
+  int8_t load_state_;     // Of type LibraryState.
   bool corelib_imported_;
   bool is_dart_scheme_;
-  bool debuggable_;              // True if debugger can stop in library.
-  bool is_in_fullsnapshot_;      // True if library is in a full snapshot.
+  bool debuggable_;          // True if debugger can stop in library.
+  bool is_in_fullsnapshot_;  // True if library is in a full snapshot.
 
   friend class Class;
   friend class Isolate;
 };
 
 
 class RawNamespace : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Namespace);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->library_);
-  }
-  RawLibrary* library_;          // library with name dictionary.
-  RawArray* show_names_;         // list of names that are exported.
-  RawArray* hide_names_;         // blacklist of names that are not exported.
-  RawField* metadata_field_;     // remembers the token pos of metadata if any,
-                                 // and the metadata values if computed.
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->library_); }
+  RawLibrary* library_;       // library with name dictionary.
+  RawArray* show_names_;      // list of names that are exported.
+  RawArray* hide_names_;      // blacklist of names that are not exported.
+  RawField* metadata_field_;  // remembers the token pos of metadata if any,
+                              // and the metadata values if computed.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->metadata_field_);
   }
 };
 
 
 class RawCode : public RawObject {
   enum InlinedMetadataIndex {
     kInlinedIntervalsIndex = 0,
     kInlinedIdToFunctionIndex = 1,
     kInlinedCallerIdMapIndex = 2,
     kInlinedIdToTokenPosIndex = 3,
     kInlinedMetadataSize = 4,
   };
 
   RAW_HEAP_OBJECT_IMPLEMENTATION(Code);
 
-  uword entry_point_;  // Accessed from generated code.
+  uword entry_point_;          // Accessed from generated code.
   uword checked_entry_point_;  // Accessed from generated code (AOT only).
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->object_pool_);
   }
-  RawObjectPool* object_pool_;  // Accessed from generated code.
+  RawObjectPool* object_pool_;     // Accessed from generated code.
   RawInstructions* instructions_;  // Accessed from generated code.
   // If owner_ is Function::null() the owner is a regular stub.
   // If owner_ is a Class the owner is the allocation stub for that class.
   // Else, owner_ is a regular Dart Function.
   RawObject* owner_;  // Function, Null, or a Class.
   RawExceptionHandlers* exception_handlers_;
   RawPcDescriptors* pc_descriptors_;
   RawArray* stackmaps_;
   NOT_IN_PRECOMPILED(RawInstructions* active_instructions_);
   NOT_IN_PRECOMPILED(RawArray* deopt_info_array_);
@@ skipping 23 matching lines @@
   // Alive: If true, the embedded object pointers will be visited during GC.
   int32_t state_bits_;
 
   // Variable length data follows here.
   int32_t* data() { OPEN_ARRAY_START(int32_t, int32_t); }
   const int32_t* data() const { OPEN_ARRAY_START(int32_t, int32_t); }
 
   static bool ContainsPC(RawObject* raw_obj, uword pc);
 
   friend class Function;
-  template<bool> friend class MarkingVisitorBase;
+  template <bool>
+  friend class MarkingVisitorBase;
   friend class SkippedCodeFunctions;
   friend class StackFrame;
   friend class Profiler;
   friend class FunctionDeserializationCluster;
 };
 
 
 class RawObjectPool : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ObjectPool);
 
@@ skipping 25 matching lines @@
 
   // Private helper function used while visiting stack frames. The
   // code which iterates over dart frames is also called during GC and
   // is not allowed to create handles.
   static bool ContainsPC(RawInstructions* raw_instr, uword pc);
 
   friend class RawCode;
   friend class RawFunction;
   friend class Code;
   friend class StackFrame;
-  template<bool> friend class MarkingVisitorBase;
+  template <bool>
+  friend class MarkingVisitorBase;
   friend class SkippedCodeFunctions;
   friend class Function;
   friend class InstructionsReader;
   friend class InstructionsWriter;
 };
 
 
 class RawPcDescriptors : public RawObject {
  public:
   enum Kind {
-    kDeopt           = 1,  // Deoptimization continuation point.
-    kIcCall          = kDeopt << 1,  // IC call.
-    kUnoptStaticCall = kIcCall << 1,  // Call to a known target via stub.
-    kRuntimeCall     = kUnoptStaticCall << 1,  // Runtime call.
-    kOsrEntry        = kRuntimeCall << 1,  // OSR entry point in unopt. code.
-    kOther           = kOsrEntry << 1,
-    kLastKind        = kOther,
-    kAnyKind         = -1
+    kDeopt = 1,                            // Deoptimization continuation point.
+    kIcCall = kDeopt << 1,                 // IC call.
+    kUnoptStaticCall = kIcCall << 1,       // Call to a known target via stub.
+    kRuntimeCall = kUnoptStaticCall << 1,  // Runtime call.
+    kOsrEntry = kRuntimeCall << 1,         // OSR entry point in unopt. code.
+    kOther = kOsrEntry << 1,
+    kLastKind = kOther,
+    kAnyKind = -1
   };
 
   class MergedKindTry {
    public:
     // Most of the time try_index will be small and merged field will fit into
     // one byte.
     static intptr_t Encode(intptr_t kind, intptr_t try_index) {
       intptr_t kind_shift = Utils::ShiftForPowerOfTwo(kind);
       ASSERT(Utils::IsUint(kKindShiftSize, kind_shift));
       ASSERT(Utils::IsInt(kTryIndexSize, try_index));
@@ skipping 55 matching lines @@
 //
 // The bit map representation is optimized for dense and small bit maps, without
 // any upper bound.
 class RawStackmap : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Stackmap);
 
   // Regarding changing this to a bitfield: ARM64 requires register_bit_count_
   // to be as large as 96, meaning 7 bits, leaving 25 bits for the length, or
   // as large as ~33 million entries. If that is sufficient, then these two
   // fields can be merged into a BitField.
-  int32_t length_;  // Length of payload, in bits.
+  int32_t length_;               // Length of payload, in bits.
   int32_t slow_path_bit_count_;  // Slow path live values, included in length_.
 
   // Offset from code entry point corresponding to this stack map
   // representation.
   uint32_t pc_offset_;
 
   // Variable length data follows here (bitmap of the stack layout).
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
 };
@@ skipping 14 matching lines @@
     kIndexPos = kKindPos + kKindSize,
     // Since there are 24 bits for the stack slot index, Functions can have
     // only ~16.7 million stack slots.
     kPayloadSize = sizeof(int32_t) * kBitsPerByte,
     kIndexSize = kPayloadSize - kIndexPos,
     kIndexBias = 1 << (kIndexSize - 1),
     kMaxIndex = (1 << (kIndexSize - 1)) - 1,
   };
 
   class IndexBits : public BitField<int32_t, int32_t, kIndexPos, kIndexSize> {};
-  class KindBits : public BitField<int32_t, int8_t, kKindPos, kKindSize>{};
+  class KindBits : public BitField<int32_t, int8_t, kKindPos, kKindSize> {};
 
   struct VarInfo {
     int32_t index_kind;  // Bitfield for slot index on stack or in context,
                          // and Entry kind of type VarInfoKind.
-    TokenPosition declaration_pos;   // Token position of declaration.
-    TokenPosition begin_pos;   // Token position of scope start.
-    TokenPosition end_pos;     // Token position of scope end.
-    int16_t scope_id;    // Scope to which the variable belongs.
+    TokenPosition declaration_pos;  // Token position of declaration.
+    TokenPosition begin_pos;        // Token position of scope start.
+    TokenPosition end_pos;          // Token position of scope end.
+    int16_t scope_id;               // Scope to which the variable belongs.
 
     VarInfoKind kind() const {
       return static_cast<VarInfoKind>(KindBits::decode(index_kind));
     }
     void set_kind(VarInfoKind kind) {
       index_kind = KindBits::update(kind, index_kind);
     }
-    int32_t index() const {
-      return IndexBits::decode(index_kind) - kIndexBias;
-    }
+    int32_t index() const { return IndexBits::decode(index_kind) - kIndexBias; }
     void set_index(int32_t index) {
       index_kind = IndexBits::update(index + kIndexBias, index_kind);
     }
   };
 
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors);
   int32_t num_entries_;  // Number of descriptors.
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->names()[0]);
   }
   RawString** names() {
     // Array of [num_entries_] variable names.
     OPEN_ARRAY_START(RawString*, RawString*);
   }
-  RawString** nameAddrAt(intptr_t i) {
-    return &(ptr()->names()[i]);
-  }
+  RawString** nameAddrAt(intptr_t i) { return &(ptr()->names()[i]); }
 
   RawObject** to(intptr_t num_entries) {
     return reinterpret_cast<RawObject**>(nameAddrAt(num_entries - 1));
   }
 
   // Variable info with [num_entries_] entries.
   VarInfo* data() {
     return reinterpret_cast<VarInfo*>(nameAddrAt(ptr()->num_entries_));
   }
 
   friend class Object;
 };
 
 
 class RawExceptionHandlers : public RawObject {
  public:
   // The index into the ExceptionHandlers table corresponds to
   // the try_index of the handler.
   struct HandlerInfo {
     uint32_t handler_pc_offset;  // PC offset value of handler.
-    int16_t outer_try_index;   // Try block index of enclosing try block.
-    int8_t needs_stacktrace;   // True if a stacktrace is needed.
-    int8_t has_catch_all;      // Catches all exceptions.
+    int16_t outer_try_index;     // Try block index of enclosing try block.
+    int8_t needs_stacktrace;     // True if a stacktrace is needed.
+    int8_t has_catch_all;        // Catches all exceptions.
   };
 
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers);
 
   // Number of exception handler entries.
   int32_t num_entries_;
 
   // Array with [num_entries_] entries. Each entry is an array of all handled
   // exception types.
@@ skipping 10 matching lines @@
 class RawContext : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Context);
 
   int32_t num_variables_;
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->parent_); }
   RawContext* parent_;
 
   // Variable length data follows here.
   RawObject** data() { OPEN_ARRAY_START(RawObject*, RawObject*); }
-  RawObject* const* data() const {
-      OPEN_ARRAY_START(RawObject*, RawObject*);
-  }
+  RawObject* const* data() const { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject** to(intptr_t num_vars) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[num_vars - 1]);
   }
 
   friend class SnapshotReader;
 };
 
 
 class RawContextScope : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
@@ skipping 35 matching lines @@
   }
 
   friend class Object;
   friend class RawClosureData;
   friend class SnapshotReader;
 };
 
 
 class RawSingleTargetCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(SingleTargetCache);
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->target_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->target_); }
   RawCode* target_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->target_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->target_); }
   uword entry_point_;
   classid_t lower_limit_;
   classid_t upper_limit_;
 };
 
 
 class RawUnlinkedCall : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnlinkedCall);
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->target_name_);
   }
   RawString* target_name_;
   RawArray* args_descriptor_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->args_descriptor_);
   }
 };
 
 
 class RawICData : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ICData);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->ic_data_);
-  }
-  RawArray* ic_data_;  // Contains class-ids, target and count.
-  RawString* target_name_;  // Name of target function.
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->ic_data_); }
+  RawArray* ic_data_;          // Contains class-ids, target and count.
+  RawString* target_name_;     // Name of target function.
   RawArray* args_descriptor_;  // Arguments descriptor.
   RawObject* owner_;  // Parent/calling function or original IC of cloned IC.
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->owner_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->owner_); }
   RawObject** to_snapshot(Snapshot::Kind kind) {
     switch (kind) {
       case Snapshot::kAppNoJIT:
         return reinterpret_cast<RawObject**>(&ptr()->args_descriptor_);
       case Snapshot::kCore:
       case Snapshot::kScript:
       case Snapshot::kAppWithJIT:
         return to();
       case Snapshot::kMessage:
       case Snapshot::kNone:
       case Snapshot::kInvalid:
         break;
     }
     UNREACHABLE();
     return NULL;
   }
   NOT_IN_PRECOMPILED(int32_t deopt_id_);
   uint32_t state_bits_;  // Number of arguments tested in IC, deopt reasons.
 #if defined(TAG_IC_DATA)
   intptr_t tag_;  // Debugging, verifying that the icdata is assigned to the
                   // same instruction again. Store -1 or Instruction::Tag.
 #endif
 };
 
 
 class RawMegamorphicCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->buckets_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->buckets_); }
   RawArray* buckets_;
   RawSmi* mask_;
   RawString* target_name_;     // Name of target function.
   RawArray* args_descriptor_;  // Arguments descriptor.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->args_descriptor_);
   }
 
   int32_t filled_entry_count_;
 };
 
 
 class RawSubtypeTestCache : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache);
   RawArray* cache_;
 };
 
 
 class RawError : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Error);
 };
 
 
 class RawApiError : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ApiError);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->message_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->message_); }
   RawString* message_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->message_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->message_); }
 };
 
 
 class RawLanguageError : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LanguageError);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->previous_error_);
   }
   RawError* previous_error_;  // May be null.
   RawScript* script_;
   RawString* message_;
   RawString* formatted_message_;  // Incl. previous error's formatted message.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->formatted_message_);
   }
   TokenPosition token_pos_;  // Source position in script_.
   bool report_after_token_;  // Report message at or after the token.
-  int8_t kind_;  // Of type Report::Kind.
+  int8_t kind_;              // Of type Report::Kind.
 };
 
 
 class RawUnhandledException : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnhandledException);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->exception_);
   }
   RawInstance* exception_;
   RawInstance* stacktrace_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->stacktrace_);
   }
 };
 
 
 class RawUnwindError : public RawError {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnwindError);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->message_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->message_); }
   RawString* message_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->message_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->message_); }
   bool is_user_initiated_;
   bool is_vm_restart_;
 };
 
 
 class RawInstance : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instance);
 };
 
 
 class RawLibraryPrefix : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
-  RawString* name_;               // Library prefix name.
-  RawLibrary* importer_;          // Library which declares this prefix.
-  RawArray* imports_;             // Libraries imported with this prefix.
-  RawArray* dependent_code_;      // Code that refers to deferred, unloaded
-                                  // library prefix.
+  RawString* name_;           // Library prefix name.
+  RawLibrary* importer_;      // Library which declares this prefix.
+  RawArray* imports_;         // Libraries imported with this prefix.
+  RawArray* dependent_code_;  // Code that refers to deferred, unloaded
+                              // library prefix.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->dependent_code_);
   }
   RawObject** to_snapshot(Snapshot::Kind kind) {
     switch (kind) {
       case Snapshot::kCore:
       case Snapshot::kScript:
       case Snapshot::kAppWithJIT:
         return reinterpret_cast<RawObject**>(&ptr()->imports_);
       case Snapshot::kAppNoJIT:
         return reinterpret_cast<RawObject**>(&ptr()->importer_);
       case Snapshot::kMessage:
       case Snapshot::kNone:
       case Snapshot::kInvalid:
         break;
     }
     UNREACHABLE();
     return NULL;
   }
-  uint16_t num_imports_;          // Number of library entries in libraries_.
+  uint16_t num_imports_;  // Number of library entries in libraries_.
   bool is_deferred_load_;
   bool is_loaded_;
 };
 
 
 class RawAbstractType : public RawInstance {
  protected:
   enum TypeState {
-    kAllocated,  // Initial state.
-    kResolved,  // Type class and type arguments resolved.
-    kBeingFinalized,  // In the process of being finalized.
-    kFinalizedInstantiated,  // Instantiated type ready for use.
+    kAllocated,                // Initial state.
+    kResolved,                 // Type class and type arguments resolved.
+    kBeingFinalized,           // In the process of being finalized.
+    kFinalizedInstantiated,    // Instantiated type ready for use.
     kFinalizedUninstantiated,  // Uninstantiated type ready for use.
   };
 
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractType);
 
   friend class ObjectStore;
 };
 
 
 class RawType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(Type);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_class_id_);
   }
   // Either the id of the resolved class as a Smi or an UnresolvedClass.
   RawObject* type_class_id_;
   RawTypeArguments* arguments_;
   RawSmi* hash_;
   // This type object represents a function type if its signature field is a
   // non-null function object.
   // If this type is malformed or malbounded, the signature field gets
   // overwritten by the error object in order to save space. If the type is a
   // function type, its signature is lost, but the message in the error object
   // can describe the issue without needing the signature.
   union {
-    RawFunction* signature_;  // If not null, this type is a function type.
+    RawFunction* signature_;   // If not null, this type is a function type.
     RawLanguageError* error_;  // If not null, type is malformed or malbounded.
   } sig_or_err_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->sig_or_err_.error_);
   }
   TokenPosition token_pos_;
   int8_t type_state_;
 
   friend class CidRewriteVisitor;
 };
 
 
 class RawTypeRef : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeRef);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->type_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
   RawAbstractType* type_;  // The referenced type.
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->type_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
 };
 
 
 class RawTypeParameter : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->name_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawSmi* hash_;
   RawAbstractType* bound_;  // ObjectType if no explicit bound specified.
   RawFunction* parameterized_function_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->parameterized_function_);
   }
   classid_t parameterized_class_id_;
   TokenPosition token_pos_;
   int16_t index_;
   uint8_t parent_level_;  // Max 255 levels of nested generic functions is OK.
   int8_t type_state_;
 
   friend class CidRewriteVisitor;
 };
 
 
 class RawBoundedType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(BoundedType);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->type_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
   RawAbstractType* type_;
   RawAbstractType* bound_;
   RawSmi* hash_;
   RawTypeParameter* type_parameter_;  // For more detailed error reporting.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->type_parameter_);
   }
 };
 
 
@@ skipping 18 matching lines @@
   RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
 
   RawTypeArguments* type_arguments_;
   RawFunction* function_;
   RawContext* context_;
 
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->context_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->context_); }
 };
 
 
 class RawNumber : public RawInstance {
   RAW_OBJECT_IMPLEMENTATION(Number);
 };
 
 
 class RawInteger : public RawNumber {
   RAW_OBJECT_IMPLEMENTATION(Integer);
@@ skipping 69 matching lines @@
 
   // Variable length data follows here.
   uint16_t* data() { OPEN_ARRAY_START(uint16_t, uint16_t); }
   const uint16_t* data() const { OPEN_ARRAY_START(uint16_t, uint16_t); }
 
   friend class SnapshotReader;
   friend class RODataSerializationCluster;
 };
 
 
-template<typename T>
+template <typename T>
 class ExternalStringData {
  public:
-  ExternalStringData(const T* data, void* peer, Dart_PeerFinalizer callback) :
-      data_(data), peer_(peer), callback_(callback) {
-  }
+  ExternalStringData(const T* data, void* peer, Dart_PeerFinalizer callback)
+      : data_(data), peer_(peer), callback_(callback) {}
   ~ExternalStringData() {
     if (callback_ != NULL) (*callback_)(peer_);
   }
 
-  const T* data() {
-    return data_;
-  }
-  void* peer() {
-    return peer_;
-  }
+  const T* data() { return data_; }
+  void* peer() { return peer_; }
 
   static intptr_t data_offset() {
     return OFFSET_OF(ExternalStringData<T>, data_);
   }
 
  private:
   const T* data_;
   void* peer_;
   Dart_PeerFinalizer callback_;
 };
 
 
 class RawExternalOneByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalOneByteString);
+
  public:
   typedef ExternalStringData<uint8_t> ExternalData;
 
  private:
   ExternalData* external_data_;
   friend class Api;
 };
 
 
 class RawExternalTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString);
+
  public:
   typedef ExternalStringData<uint16_t> ExternalData;
 
  private:
   ExternalData* external_data_;
   friend class Api;
 };
 
 
 class RawBool : public RawInstance {
@@ skipping 21 matching lines @@
   friend class LinkedHashMapSerializationCluster;
   friend class LinkedHashMapDeserializationCluster;
   friend class Deserializer;
   friend class RawCode;
   friend class RawImmutableArray;
   friend class SnapshotReader;
   friend class GrowableObjectArray;
   friend class LinkedHashMap;
   friend class RawLinkedHashMap;
   friend class Object;
-  friend class ICData;  // For high performance access.
+  friend class ICData;            // For high performance access.
   friend class SubtypeTestCache;  // For high performance access.
 };
 
 
 class RawImmutableArray : public RawArray {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray);
 
   friend class SnapshotReader;
 };
 
 
 class RawGrowableObjectArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawSmi* length_;
   RawArray* data_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->data_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->data_); }
 
   friend class SnapshotReader;
 };
 
 
 class RawLinkedHashMap : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
@@ skipping 123 matching lines @@
 
 
 class RawReceivePort : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ReceivePort);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->send_port_);
   }
   RawSendPort* send_port_;
   RawInstance* handler_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->handler_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->handler_); }
 };
 
 
 // VM type for capturing stacktraces when exceptions are thrown,
 // Currently we don't have any interface that this object is supposed
 // to implement so we just support the 'toString' method which
 // converts the stack trace into a string.
 class RawStacktrace : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Stacktrace);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->code_array_);
   }
-  RawArray* code_array_;  // Code object for each frame in the stack trace.
+  RawArray* code_array_;       // Code object for each frame in the stack trace.
   RawArray* pc_offset_array_;  // Offset of PC for each frame.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->pc_offset_array_);
   }
   // False for pre-allocated stack trace (used in OOM and Stack overflow).
   bool expand_inlined_;
 };
 
 
 // VM type for capturing JS regular expressions.
@@ skipping 20 matching lines @@
   // A bitfield with two fields:
   // type: Uninitialized, simple or complex.
   // flags: Represents global/local, case insensitive, multiline.
   int8_t type_flags_;
 };
 
 
 class RawWeakProperty : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(WeakProperty);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->key_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->key_); }
   RawObject* key_;
   RawObject* value_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->value_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->value_); }
 
   // Linked list is chaining all pending weak properties.
   // Untyped to make it clear that it is not to be visited by GC.
   uword next_;
 
   friend class GCMarker;
-  template<bool> friend class MarkingVisitorBase;
+  template <bool>
+  friend class MarkingVisitorBase;
   friend class Scavenger;
   friend class ScavengerVisitor;
 };
 
 // MirrorReferences are used by mirrors to hold reflectees that are VM
 // internal objects, such as libraries, classes, functions or types.
 class RawMirrorReference : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(MirrorReference);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->referent_);
   }
   RawObject* referent_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->referent_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->referent_); }
 };
 
 
 // UserTag are used by the profiler to track Dart script state.
 class RawUserTag : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UserTag);
 
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->label_);
-  }
+  RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->label_); }
 
   RawString* label_;
 
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->label_);
-  }
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->label_); }
 
   // Isolate unique tag.
   uword tag_;
 
   friend class SnapshotReader;
   friend class Object;
 
  public:
   uword tag() const { return tag_; }
 };
 
 // Class Id predicates.
 
 inline bool RawObject::IsErrorClassId(intptr_t index) {
   // Make sure this function is updated when new Error types are added.
-  COMPILE_ASSERT(kApiErrorCid == kErrorCid + 1 &&
-                 kLanguageErrorCid == kErrorCid + 2 &&
-                 kUnhandledExceptionCid == kErrorCid + 3 &&
-                 kUnwindErrorCid == kErrorCid + 4 &&
-                 kInstanceCid == kErrorCid + 5);
+  COMPILE_ASSERT(
+      kApiErrorCid == kErrorCid + 1 && kLanguageErrorCid == kErrorCid + 2 &&
+      kUnhandledExceptionCid == kErrorCid + 3 &&
+      kUnwindErrorCid == kErrorCid + 4 && kInstanceCid == kErrorCid + 5);
   return (index >= kErrorCid && index < kInstanceCid);
 }
 
 
 inline bool RawObject::IsNumberClassId(intptr_t index) {
   // Make sure this function is updated when new Number types are added.
-  COMPILE_ASSERT(kIntegerCid == kNumberCid + 1 &&
-                 kSmiCid == kNumberCid + 2 &&
-                 kMintCid == kNumberCid + 3 &&
-                 kBigintCid == kNumberCid + 4 &&
+  COMPILE_ASSERT(kIntegerCid == kNumberCid + 1 && kSmiCid == kNumberCid + 2 &&
+                 kMintCid == kNumberCid + 3 && kBigintCid == kNumberCid + 4 &&
                  kDoubleCid == kNumberCid + 5);
   return (index >= kNumberCid && index < kBoolCid);
 }
 
 
 inline bool RawObject::IsIntegerClassId(intptr_t index) {
   // Make sure this function is updated when new Integer types are added.
-  COMPILE_ASSERT(kSmiCid == kIntegerCid + 1 &&
-                 kMintCid == kIntegerCid + 2 &&
+  COMPILE_ASSERT(kSmiCid == kIntegerCid + 1 && kMintCid == kIntegerCid + 2 &&
                  kBigintCid == kIntegerCid + 3 &&
                  kDoubleCid == kIntegerCid + 4);
   return (index >= kIntegerCid && index < kDoubleCid);
 }
 
 
 inline bool RawObject::IsStringClassId(intptr_t index) {
   // Make sure this function is updated when new StringCid types are added.
   COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
                  kTwoByteStringCid == kStringCid + 2 &&
@@ skipping 31 matching lines @@
                  kExternalTwoByteStringCid == kStringCid + 4);
   return (index == kExternalOneByteStringCid ||
           index == kExternalTwoByteStringCid);
 }
 
 
 inline bool RawObject::IsBuiltinListClassId(intptr_t index) {
   // Make sure this function is updated when new builtin List types are added.
   COMPILE_ASSERT(kImmutableArrayCid == kArrayCid + 1);
   return ((index >= kArrayCid && index <= kImmutableArrayCid) ||
-          (index == kGrowableObjectArrayCid) ||
-          IsTypedDataClassId(index) ||
-          IsTypedDataViewClassId(index) ||
-          IsExternalTypedDataClassId(index) ||
+          (index == kGrowableObjectArrayCid) || IsTypedDataClassId(index) ||
+          IsTypedDataViewClassId(index) || IsExternalTypedDataClassId(index) ||
           (index == kByteBufferCid));
 }
 
 
 inline bool RawObject::IsTypedDataClassId(intptr_t index) {
   // Make sure this is updated when new TypedData types are added.
   COMPILE_ASSERT(kTypedDataUint8ArrayCid == kTypedDataInt8ArrayCid + 1 &&
                  kTypedDataUint8ClampedArrayCid == kTypedDataInt8ArrayCid + 2 &&
                  kTypedDataInt16ArrayCid == kTypedDataInt8ArrayCid + 3 &&
                  kTypedDataUint16ArrayCid == kTypedDataInt8ArrayCid + 4 &&
@@ skipping 23 matching lines @@
       kTypedDataUint32ArrayViewCid == kTypedDataInt8ArrayViewCid + 6 &&
       kTypedDataInt64ArrayViewCid == kTypedDataInt8ArrayViewCid + 7 &&
       kTypedDataUint64ArrayViewCid == kTypedDataInt8ArrayViewCid + 8 &&
       kTypedDataFloat32ArrayViewCid == kTypedDataInt8ArrayViewCid + 9 &&
       kTypedDataFloat64ArrayViewCid == kTypedDataInt8ArrayViewCid + 10 &&
       kTypedDataFloat32x4ArrayViewCid == kTypedDataInt8ArrayViewCid + 11 &&
       kTypedDataInt32x4ArrayViewCid == kTypedDataInt8ArrayViewCid + 12 &&
       kTypedDataFloat64x2ArrayViewCid == kTypedDataInt8ArrayViewCid + 13 &&
       kByteDataViewCid == kTypedDataInt8ArrayViewCid + 14 &&
       kExternalTypedDataInt8ArrayCid == kTypedDataInt8ArrayViewCid + 15);
-  return (index >= kTypedDataInt8ArrayViewCid &&
-          index <= kByteDataViewCid);
+  return (index >= kTypedDataInt8ArrayViewCid && index <= kByteDataViewCid);
 }
 
 
 inline bool RawObject::IsExternalTypedDataClassId(intptr_t index) {
   // Make sure this is updated when new ExternalTypedData types are added.
   COMPILE_ASSERT(
-      (kExternalTypedDataUint8ArrayCid ==
-       kExternalTypedDataInt8ArrayCid + 1) &&
+      (kExternalTypedDataUint8ArrayCid == kExternalTypedDataInt8ArrayCid + 1) &&
       (kExternalTypedDataUint8ClampedArrayCid ==
        kExternalTypedDataInt8ArrayCid + 2) &&
-      (kExternalTypedDataInt16ArrayCid ==
-       kExternalTypedDataInt8ArrayCid + 3) &&
+      (kExternalTypedDataInt16ArrayCid == kExternalTypedDataInt8ArrayCid + 3) &&
       (kExternalTypedDataUint16ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 4) &&
-      (kExternalTypedDataInt32ArrayCid ==
-       kExternalTypedDataInt8ArrayCid + 5) &&
+      (kExternalTypedDataInt32ArrayCid == kExternalTypedDataInt8ArrayCid + 5) &&
       (kExternalTypedDataUint32ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 6) &&
-      (kExternalTypedDataInt64ArrayCid ==
-       kExternalTypedDataInt8ArrayCid + 7) &&
+      (kExternalTypedDataInt64ArrayCid == kExternalTypedDataInt8ArrayCid + 7) &&
       (kExternalTypedDataUint64ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 8) &&
       (kExternalTypedDataFloat32ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 9) &&
       (kExternalTypedDataFloat64ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 10) &&
       (kExternalTypedDataFloat32x4ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 11) &&
       (kExternalTypedDataInt32x4ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 12) &&
       (kExternalTypedDataFloat64x2ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 13) &&
       (kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14));
   return (index >= kExternalTypedDataInt8ArrayCid &&
           index <= kExternalTypedDataFloat64x2ArrayCid);
 }
 
 
 inline bool RawObject::IsInternalVMdefinedClassId(intptr_t index) {
   return ((index < kNumPredefinedCids) &&
           !RawObject::IsImplicitFieldClassId(index));
 }
 
 
 inline bool RawObject::IsVariableSizeClassId(intptr_t index) {
-  return (index == kArrayCid) ||
-         (index == kImmutableArrayCid) ||
+  return (index == kArrayCid) || (index == kImmutableArrayCid) ||
          RawObject::IsOneByteStringClassId(index) ||
          RawObject::IsTwoByteStringClassId(index) ||
-         RawObject::IsTypedDataClassId(index) ||
-         (index == kContextCid) ||
-         (index == kTypeArgumentsCid) ||
-         (index == kInstructionsCid) ||
-         (index == kObjectPoolCid) ||
-         (index == kPcDescriptorsCid) ||
-         (index == kCodeSourceMapCid) ||
-         (index == kStackmapCid) ||
+         RawObject::IsTypedDataClassId(index) || (index == kContextCid) ||
+         (index == kTypeArgumentsCid) || (index == kInstructionsCid) ||
+         (index == kObjectPoolCid) || (index == kPcDescriptorsCid) ||
+         (index == kCodeSourceMapCid) || (index == kStackmapCid) ||
          (index == kLocalVarDescriptorsCid) ||
-         (index == kExceptionHandlersCid) ||
-         (index == kCodeCid) ||
-         (index == kContextScopeCid) ||
-         (index == kInstanceCid) ||
+         (index == kExceptionHandlersCid) || (index == kCodeCid) ||
+         (index == kContextScopeCid) || (index == kInstanceCid) ||
          (index == kRegExpCid);
 }
 
 
 // This is a set of classes that are not Dart classes whose representation
 // is defined by the VM but are used in the VM code by computing the
 // implicit field offsets of the various fields in the dart object.
 inline bool RawObject::IsImplicitFieldClassId(intptr_t index) {
   return (IsTypedDataViewClassId(index) || index == kByteBufferCid);
 }
 
 
 inline intptr_t RawObject::NumberOfTypedDataClasses() {
   // Make sure this is updated when new TypedData types are added.
   COMPILE_ASSERT(kTypedDataInt8ArrayViewCid == kTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_RAW_OBJECT_H_