VM: Re-format to use at most one newline between functions

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/exceptions.h"
@@ skipping 122 matching lines @@
 
 #define CLASS_LIST_NO_OBJECT(V)                                                \
   CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY(V)                                 \
   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;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 
-
 enum ClassId {
   // Illegal class id.
   kIllegalCid = 0,
 
   // A sentinel used by the vm service's heap snapshots to represent references
   // from the stack.
   kStackCid = 1,
 
   // The following entries describes classes for pseudo-objects in the heap
   // that should never be reachable from live objects. Free list elements
@@ skipping 526 matching lines @@
   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.
     kRefinalizeAfterPatch,  // Class needs to be refinalized (patched).
   };
 
  private:
@@ skipping 53 matching lines @@
   friend class Isolate;
   friend class Object;
   friend class RawInstance;
   friend class RawInstructions;
   friend class RawTypeArguments;
   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_or_library_prefix_);
   }
   RawObject* library_or_library_prefix_;  // Library or library prefix qualifier
                                           // for the 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_);
   }
   // The instantiations_ array remains empty for instantiated type arguments.
   RawArray* instantiations_;  // Array of paired canonical vectors:
                               // Even index: instantiator.
@@ skipping 11 matching lines @@
     OPEN_ARRAY_START(RawAbstractType*, RawAbstractType*);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types()[length - 1]);
   }
 
   friend class Object;
   friend class SnapshotReader;
 };
 
-
 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_); }
 
   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.
@@ skipping 61 matching lines @@
   uint32_t kind_tag_;                          // See Function::KindTagBits.
   int16_t num_fixed_parameters_;
   int16_t num_optional_parameters_;  // > 0: positional; < 0: named.
   NOT_IN_PRECOMPILED(intptr_t kernel_offset_);
   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_snapshot() {
     return reinterpret_cast<RawObject**>(&ptr()->closure_);
   }
   RawObject* hash_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->hash_); }
 
   friend class Function;
 };
 
-
 class RawSignatureData : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(SignatureData);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->parent_function_);
   }
   RawFunction* parent_function_;  // Enclosing function of this sig. function.
   RawType* signature_type_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->signature_type_);
   }
 
   friend class Function;
 };
 
-
 class RawRedirectionData : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(RedirectionData);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
   RawType* type_;
   RawString* identifier_;
   RawFunction* 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.
@@ skipping 39 matching lines @@
   // guarded_cid_. Stored corrected by -kHeapObjectTag to simplify code
   // generated on platforms with weak addressing modes (ARM).
   int8_t guarded_list_length_in_object_offset_;
 
   uint8_t kind_bits_;  // static, final, const, has initializer....
   NOT_IN_PRECOMPILED(intptr_t kernel_offset_);
 
   friend class CidRewriteVisitor;
 };
 
-
 class RawLiteralToken : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LiteralToken);
 
   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_); }
   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_); }
 
   friend class SnapshotReader;
 };
 
-
 class RawScript : public RawObject {
  public:
   enum Kind {
     kScriptTag = 0,
     kLibraryTag,
     kSourceTag,
     kPatchTag,
     kEvaluateTag,
     kKernelTag,
   };
@@ skipping 33 matching lines @@
 
   int32_t line_offset_;
   int32_t col_offset_;
   int8_t kind_;  // Of type Kind.
   int64_t load_timestamp_;
   const uint8_t* kernel_data_;
   intptr_t kernel_data_size_;
   intptr_t kernel_script_index_;
 };
 
-
 class RawLibrary : public RawObject {
   enum LibraryState {
     kAllocated,       // Initial state.
     kLoadRequested,   // Compiler or script requested load of library.
     kLoadInProgress,  // Library is in the process of being loaded.
     kLoaded,          // Library is loaded.
     kLoadError,       // Error occurred during load of the Library.
   };
 
   RAW_HEAP_OBJECT_IMPLEMENTATION(Library);
@@ skipping 26 matching lines @@
   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.
 
   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** to() {
     return reinterpret_cast<RawObject**>(&ptr()->metadata_field_);
   }
 };
 
-
 class RawCode : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(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.
@@ skipping 46 matching lines @@
 
   friend class Function;
   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);
 
   intptr_t length_;
   RawTypedData* info_array_;
 
   struct Entry {
     union {
       RawObject* raw_obj_;
       uword raw_value_;
     };
   };
   Entry* data() { OPEN_ARRAY_START(Entry, Entry); }
   Entry const* data() const { OPEN_ARRAY_START(Entry, Entry); }
 
   Entry* first_entry() { return &ptr()->data()[0]; }
 
   friend class Object;
 };
 
-
 class RawInstructions : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instructions);
 
   // Instructions size in bytes and flags.
   // Currently, only flag indicates 1 or 2 entry points.
   uint32_t size_and_flags_;
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
 
   // 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;
   friend class SkippedCodeFunctions;
   friend class Function;
   friend class ImageReader;
   friend class ImageWriter;
 };
 
-
 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.
     kRewind = kOsrEntry << 1,              // Call rewind target address.
     kOther = kRewind << 1,
@@ skipping 40 matching lines @@
   // platforms.
   uword length_;
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, intptr_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, intptr_t); }
 
   friend class Object;
 };
 
-
 // CodeSourceMap encodes a mapping from code PC ranges to source token
 // positions and the stack of inlined functions.
 class RawCodeSourceMap : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(CodeSourceMap);
 
   // Length in bytes.  This only needs to be an int32_t, but we make it a uword
   // so that the variable length data is 64 bit aligned on 64 bit platforms.
   uword length_;
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, intptr_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, intptr_t); }
 
   friend class Object;
 };
 
-
 // StackMap is an immutable representation of the layout of the stack at a
 // PC. The stack map representation consists of a bit map which marks each
 // live object index starting from the base of the frame.
 //
 // 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 slow_path_bit_count_;  // Slow path live values, included in length_.
 
   // Offset from code entry point corresponding to this stack map
   // representation. This only needs to be an int32_t, but we make it a uword
   // so that the variable length data is 64 bit aligned on 64 bit platforms.
   uword 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); }
 };
 
-
 class RawLocalVarDescriptors : public RawObject {
  public:
   enum VarInfoKind {
     kStackVar = 1,
     kContextVar,
     kContextLevel,
     kSavedCurrentContext,
   };
 
   enum {
@@ skipping 52 matching lines @@
   }
 
   // Variable info with [num_entries_] entries.
   VarInfo* data() {
     return reinterpret_cast<VarInfo*>(nameAddrAt(ptr()->num_entries_));
   }
 
   friend class Object;
 };
 
-
 class RawExceptionHandlers : public RawObject {
  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.
   RawArray* handled_types_data_;
 
   // Exception handler info of length [num_entries_].
   const ExceptionHandlerInfo* data() const {
     OPEN_ARRAY_START(ExceptionHandlerInfo, intptr_t);
   }
   ExceptionHandlerInfo* data() {
     OPEN_ARRAY_START(ExceptionHandlerInfo, intptr_t);
   }
 
   friend class Object;
 };
 
-
 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** to(intptr_t num_vars) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[num_vars - 1]);
   }
 
   friend class Object;
   friend class SnapshotReader;
 };
 
-
 class RawContextScope : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
 
   // TODO(iposva): Switch to conventional enum offset based structure to avoid
   // alignment mishaps.
   struct VariableDesc {
     RawSmi* declaration_token_pos;
     RawSmi* token_pos;
     RawString* name;
     RawBool* is_final;
@@ skipping 24 matching lines @@
     uword end = reinterpret_cast<uword>(ptr()->VariableDescAddr(num_vars));
     // 'end' is the address just beyond the last descriptor, so step back.
     return reinterpret_cast<RawObject**>(end - kWordSize);
   }
 
   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_); }
   RawCode* 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.
   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_snapshot(Snapshot::Kind kind) {
@@ skipping 13 matching lines @@
     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_); }
   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_); }
   RawString* 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.
 };
 
-
 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_); }
   RawString* message_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->message_); }
   bool is_user_initiated_;
 };
 
-
 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.
   RawObject** to() {
@@ skipping 13 matching lines @@
         break;
     }
     UNREACHABLE();
     return NULL;
   }
   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.
     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_;
@@ skipping 11 matching lines @@
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->sig_or_err_.error_);
   }
   TokenPosition token_pos_;
   int8_t type_state_;
 
   friend class CidRewriteVisitor;
   friend class RawTypeArguments;
 };
 
-
 class RawTypeRef : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeRef);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->type_); }
   RawAbstractType* type_;  // The referenced 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_); }
   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_;
   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_); }
   RawAbstractType* type_;
   RawAbstractType* bound_;
   RawSmi* hash_;
   RawTypeParameter* type_parameter_;  // For more detailed error reporting.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->type_parameter_);
   }
 };
 
-
 class RawMixinAppType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(MixinAppType);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->super_type_);
   }
   RawAbstractType* super_type_;
   RawArray* mixin_types_;  // Array of AbstractType.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->mixin_types_);
   }
 };
 
-
 class RawClosure : public RawInstance {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->instantiator_type_arguments_);
   }
 
   // No instance fields should be declared before the following 4 fields whose
   // offsets must be identical in Dart and C++.
@@ skipping 10 matching lines @@
   // used to instantiate the signature of function_ when this closure is
   // involved in a type test. In other words, these fields define the function
   // type of this closure instance, but they are not used when invoking it.
   // If this closure is generic, it can be invoked with function type arguments
   // that will be processed in the prolog of the closure function_. For example,
   // if the generic closure function_ has a generic parent function, the
   // passed-in function type arguments get concatenated to the function type
   // arguments of the parent that are found in the context_.
 };
 
-
 class RawNumber : public RawInstance {
   RAW_OBJECT_IMPLEMENTATION(Number);
 };
 
-
 class RawInteger : public RawNumber {
   RAW_OBJECT_IMPLEMENTATION(Integer);
 };
 
-
 class RawSmi : public RawInteger {
   RAW_OBJECT_IMPLEMENTATION(Smi);
 };
 
-
 class RawMint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Mint);
 
   ALIGN8 int64_t value_;
 
   friend class Api;
   friend class SnapshotReader;
 };
 COMPILE_ASSERT(sizeof(RawMint) == 16);
 
-
 class RawBigint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Bigint);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->neg_); }
   RawBool* neg_;
   RawSmi* used_;
   RawTypedData* digits_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->digits_); }
 };
 
-
 class RawDouble : public RawNumber {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Double);
 
   ALIGN8 double value_;
 
   friend class Api;
   friend class SnapshotReader;
 };
 COMPILE_ASSERT(sizeof(RawDouble) == 16);
 
-
 class RawString : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(String);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
 #if !defined(HASH_IN_OBJECT_HEADER)
   RawSmi* hash_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->hash_); }
 #else
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 #endif
 
  private:
   friend class Library;
   friend class OneByteStringSerializationCluster;
   friend class TwoByteStringSerializationCluster;
   friend class OneByteStringDeserializationCluster;
   friend class TwoByteStringDeserializationCluster;
   friend class RODataSerializationCluster;
 };
 
-
 class RawOneByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(OneByteString);
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
 
   friend class ApiMessageReader;
   friend class RODataSerializationCluster;
   friend class SnapshotReader;
   friend class String;
 };
 
-
 class RawTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TwoByteString);
 
   // 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 RODataSerializationCluster;
   friend class SnapshotReader;
   friend class String;
 };
 
-
 template <typename T>
 class ExternalStringData {
  public:
   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_; }
 
   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;
   friend class String;
 };
 
-
 class RawExternalTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString);
 
  public:
   typedef ExternalStringData<uint16_t> ExternalData;
 
  private:
   ExternalData* external_data_;
   friend class Api;
   friend class String;
 };
 
-
 class RawBool : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Bool);
 
   bool value_;
 };
 
-
 class RawArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Array);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawSmi* length_;
   // Variable length data follows here.
   RawObject** data() { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject* const* data() const { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
   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 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_); }
 
   friend class SnapshotReader;
 };
 
-
 class RawLinkedHashMap : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawTypedData* index_;
   RawSmi* hash_mask_;
   RawArray* data_;
   RawSmi* used_data_;
   RawSmi* deleted_keys_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->deleted_keys_);
   }
 
   friend class SnapshotReader;
 };
 
-
 class RawFloat32x4 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Float32x4);
 
   ALIGN8 float value_[4];
 
   friend class SnapshotReader;
 
  public:
   float x() const { return value_[0]; }
   float y() const { return value_[1]; }
   float z() const { return value_[2]; }
   float w() const { return value_[3]; }
 };
 COMPILE_ASSERT(sizeof(RawFloat32x4) == 24);
 
-
 class RawInt32x4 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Int32x4);
 
   ALIGN8 int32_t value_[4];
 
   friend class SnapshotReader;
 
  public:
   int32_t x() const { return value_[0]; }
   int32_t y() const { return value_[1]; }
   int32_t z() const { return value_[2]; }
   int32_t w() const { return value_[3]; }
 };
 COMPILE_ASSERT(sizeof(RawInt32x4) == 24);
 
-
 class RawFloat64x2 : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Float64x2);
 
   ALIGN8 double value_[2];
 
   friend class SnapshotReader;
 
  public:
   double x() const { return value_[0]; }
   double y() const { return value_[1]; }
 };
 COMPILE_ASSERT(sizeof(RawFloat64x2) == 24);
 
-
 // Define an aliases for intptr_t.
 #if defined(ARCH_IS_32_BIT)
 #define kIntPtrCid kTypedDataInt32ArrayCid
 #define SetIntPtr SetInt32
 #elif defined(ARCH_IS_64_BIT)
 #define kIntPtrCid kTypedDataInt64ArrayCid
 #define SetIntPtr SetInt64
 #else
 #error Architecture is not 32-bit or 64-bit.
 #endif  // ARCH_IS_32_BIT
 
-
 class RawTypedData : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypedData);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
   const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   friend class Api;
   friend class Object;
   friend class Instance;
   friend class SnapshotReader;
   friend class ObjectPool;
   friend class RawObjectPool;
   friend class ObjectPoolSerializationCluster;
   friend class ObjectPoolDeserializationCluster;
 };
 
-
 class RawExternalTypedData : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   uint8_t* data_;
 
   friend class TokenStream;
   friend class RawTokenStream;
 };
 
 // VM implementations of the basic types in the isolate.
 class RawCapability : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Capability);
   uint64_t id_;
 };
 
-
 class RawSendPort : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(SendPort);
   Dart_Port id_;
   Dart_Port origin_id_;
 
   friend class ReceivePort;
 };
 
-
 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_); }
 };
 
-
 // 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()->async_link_);
   }
   RawStackTrace* async_link_;  // Link to parent async 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.
 class RawRegExp : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(RegExp);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->num_bracket_expressions_);
   }
   RawSmi* num_bracket_expressions_;
   RawString* pattern_;  // Pattern to be used for matching.
   union {
@@ skipping 22 matching lines @@
   }
 
   intptr_t num_registers_;
 
   // 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* key_;
   RawObject* 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.
@@ skipping 11 matching lines @@
 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_); }
 };
 
-
 // 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_); }
 
   RawString* label_;
 
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->label_); }
 
@@ skipping 11 matching lines @@
 
 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);
   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 &&
                  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 &&
                  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 &&
                  kExternalOneByteStringCid == kStringCid + 3 &&
                  kExternalTwoByteStringCid == kStringCid + 4);
   return (index >= kStringCid && index <= kExternalTwoByteStringCid);
 }
 
-
 inline bool RawObject::IsOneByteStringClassId(intptr_t index) {
   // Make sure this function is updated when new StringCid types are added.
   COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
                  kTwoByteStringCid == kStringCid + 2 &&
                  kExternalOneByteStringCid == kStringCid + 3 &&
                  kExternalTwoByteStringCid == kStringCid + 4);
   return (index == kOneByteStringCid || index == kExternalOneByteStringCid);
 }
 
-
 inline bool RawObject::IsTwoByteStringClassId(intptr_t index) {
   // Make sure this function is updated when new StringCid types are added.
   COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
                  kTwoByteStringCid == kStringCid + 2 &&
                  kExternalOneByteStringCid == kStringCid + 3 &&
                  kExternalTwoByteStringCid == kStringCid + 4);
   return (index == kTwoByteStringCid || index == kExternalTwoByteStringCid);
 }
 
-
 inline bool RawObject::IsExternalStringClassId(intptr_t index) {
   // Make sure this function is updated when new StringCid types are added.
   COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
                  kTwoByteStringCid == kStringCid + 2 &&
                  kExternalOneByteStringCid == kStringCid + 3 &&
                  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 == 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 &&
                  kTypedDataInt32ArrayCid == kTypedDataInt8ArrayCid + 5 &&
                  kTypedDataUint32ArrayCid == kTypedDataInt8ArrayCid + 6 &&
                  kTypedDataInt64ArrayCid == kTypedDataInt8ArrayCid + 7 &&
                  kTypedDataUint64ArrayCid == kTypedDataInt8ArrayCid + 8 &&
                  kTypedDataFloat32ArrayCid == kTypedDataInt8ArrayCid + 9 &&
                  kTypedDataFloat64ArrayCid == kTypedDataInt8ArrayCid + 10 &&
                  kTypedDataFloat32x4ArrayCid == kTypedDataInt8ArrayCid + 11 &&
                  kTypedDataInt32x4ArrayCid == kTypedDataInt8ArrayCid + 12 &&
                  kTypedDataFloat64x2ArrayCid == kTypedDataInt8ArrayCid + 13 &&
                  kTypedDataInt8ArrayViewCid == kTypedDataInt8ArrayCid + 14);
   return (index >= kTypedDataInt8ArrayCid &&
           index <= kTypedDataFloat64x2ArrayCid);
 }
 
-
 inline bool RawObject::IsTypedDataViewClassId(intptr_t index) {
   // Make sure this is updated when new TypedData types are added.
   COMPILE_ASSERT(
       kTypedDataUint8ArrayViewCid == kTypedDataInt8ArrayViewCid + 1 &&
       kTypedDataUint8ClampedArrayViewCid == kTypedDataInt8ArrayViewCid + 2 &&
       kTypedDataInt16ArrayViewCid == kTypedDataInt8ArrayViewCid + 3 &&
       kTypedDataUint16ArrayViewCid == kTypedDataInt8ArrayViewCid + 4 &&
       kTypedDataInt32ArrayViewCid == kTypedDataInt8ArrayViewCid + 5 &&
       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);
 }
 
-
 inline bool RawObject::IsExternalTypedDataClassId(intptr_t index) {
   // Make sure this is updated when new ExternalTypedData types are added.
   COMPILE_ASSERT(
       (kExternalTypedDataUint8ArrayCid == kExternalTypedDataInt8ArrayCid + 1) &&
       (kExternalTypedDataUint8ClampedArrayCid ==
        kExternalTypedDataInt8ArrayCid + 2) &&
       (kExternalTypedDataInt16ArrayCid == kExternalTypedDataInt8ArrayCid + 3) &&
       (kExternalTypedDataUint16ArrayCid ==
        kExternalTypedDataInt8ArrayCid + 4) &&
       (kExternalTypedDataInt32ArrayCid == kExternalTypedDataInt8ArrayCid + 5) &&
@@ skipping 10 matching lines @@
        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) ||
          RawObject::IsOneByteStringClassId(index) ||
          RawObject::IsTwoByteStringClassId(index) ||
          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 == 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_