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

runtime/vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
-#include "vm/json_stream.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
+#include "vm/json_stream.h"
 #include "vm/method_recognizer.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
 #include "vm/thread.h"
 #include "vm/token_position.h"
 
 namespace dart {
 
 // Forward declarations.
 namespace kernel {
 class Program;
 class TreeNode;
-}
+}  // namespace kernel
 
 #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class ArgumentsDescriptor;
 class Assembler;
 class Closure;
 class Code;
 class DisassemblyFormatter;
@@ skipping 795 matching lines @@
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
   REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
-
 class PassiveObject : public Object {
  public:
   void operator=(RawObject* value) { raw_ = value; }
   void operator^=(RawObject* value) { raw_ = value; }
 
   static PassiveObject& Handle(Zone* zone, RawObject* raw_ptr) {
     PassiveObject* obj =
         reinterpret_cast<PassiveObject*>(VMHandles::AllocateHandle(zone));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
@@ skipping 24 matching lines @@
   static PassiveObject& ZoneHandle(Zone* zone) {
     return ZoneHandle(zone, Object::null());
   }
 
  private:
   PassiveObject() : Object() {}
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(PassiveObject);
 };
 
-
 typedef ZoneGrowableHandlePtrArray<const AbstractType> Trail;
 typedef ZoneGrowableHandlePtrArray<const AbstractType>* TrailPtr;
 
-
 class Class : public Object {
  public:
   intptr_t instance_size() const {
     ASSERT(is_finalized() || is_prefinalized());
     return (raw_ptr()->instance_size_in_words_ * kWordSize);
   }
   void set_instance_size(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_instance_size_in_words(value_in_bytes / kWordSize);
   }
@@ skipping 618 matching lines @@
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class AbstractType;
   friend class Instance;
   friend class Object;
   friend class Type;
   friend class Intrinsifier;
   friend class ProgramVisitor;
 };
 
-
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
  public:
   RawObject* library_or_library_prefix() const {
     return raw_ptr()->library_or_library_prefix_;
   }
   RawString* ident() const { return raw_ptr()->ident_; }
   TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
 
@@ skipping 11 matching lines @@
   void set_library_or_library_prefix(const Object& library_prefix) const;
   void set_ident(const String& ident) const;
   void set_token_pos(TokenPosition token_pos) const;
 
   static RawUnresolvedClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
-
 // Classification of type genericity according to type parameter owners.
 enum Genericity {
-  kAny,              // Consider type params of current class and functions.
-  kCurrentClass,     // Consider type params of current class only.
-  kFunctions,        // Consider type params of current and parent functions.
+  kAny,           // Consider type params of current class and functions.
+  kCurrentClass,  // Consider type params of current class only.
+  kFunctions,     // Consider type params of current and parent functions.
 };
 
-
 // A TypeArguments is an array of AbstractType.
 class TypeArguments : public Object {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   intptr_t Length() const;
   RawAbstractType* TypeAt(intptr_t index) const;
@@ skipping 194 matching lines @@
   // Number of fields in the raw object=3 (instantiations_, length_ and hash_).
   static const int kNumFields = 3;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object);
   friend class AbstractType;
   friend class Class;
   friend class ClearTypeHashVisitor;
   friend class Object;
 };
 
-
 class PatchClass : public Object {
  public:
   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
   RawClass* origin_class() const { return raw_ptr()->origin_class_; }
   RawScript* script() const { return raw_ptr()->script_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
   static bool IsInFullSnapshot(RawPatchClass* cls) {
@@ skipping 10 matching lines @@
   void set_patched_class(const Class& value) const;
   void set_origin_class(const Class& value) const;
   void set_script(const Script& value) const;
 
   static RawPatchClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
   friend class Class;
 };
 
-
 class SingleTargetCache : public Object {
  public:
   RawCode* target() const { return raw_ptr()->target_; }
   void set_target(const Code& target) const;
   static intptr_t target_offset() {
     return OFFSET_OF(RawSingleTargetCache, target_);
   }
 
 #define DEFINE_NON_POINTER_FIELD_ACCESSORS(type, name)                         \
   type name() const { return raw_ptr()->name##_; }                             \
@@ skipping 13 matching lines @@
     return RoundedAllocationSize(sizeof(RawSingleTargetCache));
   }
 
   static RawSingleTargetCache* New();
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SingleTargetCache, Object);
   friend class Class;
 };
 
-
 class UnlinkedCall : public Object {
  public:
   RawString* target_name() const { return raw_ptr()->target_name_; }
   void set_target_name(const String& target_name) const;
   RawArray* args_descriptor() const { return raw_ptr()->args_descriptor_; }
   void set_args_descriptor(const Array& args_descriptor) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnlinkedCall));
   }
 
   static RawUnlinkedCall* New();
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnlinkedCall, Object);
   friend class Class;
 };
 
-
 // Object holding information about an IC: test classes and their
 // corresponding targets. The owner of the ICData can be either the function
 // or the original ICData object. In case of background compilation we
 // copy the ICData in a child object, thus freezing it during background
 // compilation. Code may contain only original ICData objects.
 class ICData : public Object {
  public:
   RawFunction* Owner() const;
 
   RawICData* Original() const;
@@ skipping 301 matching lines @@
   // A cache of VM heap allocated preinitialized empty ic data entry arrays.
   static RawArray* cached_icdata_arrays_[kCachedICDataArrayCount];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
   friend class Class;
   friend class SnapshotWriter;
   friend class Serializer;
   friend class Deserializer;
 };
 
-
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawString* UserVisibleName() const;  // Same as scrubbed name.
   RawString* QualifiedScrubbedName() const {
     return QualifiedName(kScrubbedName);
   }
   RawString* QualifiedUserVisibleName() const {
     return QualifiedName(kUserVisibleName);
   }
@@ skipping 844 matching lines @@
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
   friend class SnapshotWriter;
   friend class Parser;  // For set_eval_script.
   // RawFunction::VisitFunctionPointers accesses the private constructor of
   // Function.
   friend class RawFunction;
   friend class ClassFinalizer;  // To reset parent_function.
 };
 
-
 class ClosureData : public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClosureData));
   }
 
  private:
   RawContextScope* context_scope() const { return raw_ptr()->context_scope_; }
   void set_context_scope(const ContextScope& value) const;
 
@@ skipping 12 matching lines @@
   void set_hash(intptr_t value) const;
 
   static RawClosureData* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ClosureData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
-
 class SignatureData : public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSignatureData));
   }
 
  private:
   // Enclosing function of this signature function.
   RawFunction* parent_function() const { return raw_ptr()->parent_function_; }
   void set_parent_function(const Function& value) const;
 
   // Signature type of this signature function.
   RawType* signature_type() const { return raw_ptr()->signature_type_; }
   void set_signature_type(const Type& value) const;
 
   static RawSignatureData* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SignatureData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
-
 class RedirectionData : public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawRedirectionData));
   }
 
  private:
   // The type specifies the class and type arguments of the target constructor.
   RawType* type() const { return raw_ptr()->type_; }
   void set_type(const Type& value) const;
 
   // The optional identifier specifies a named constructor.
   RawString* identifier() const { return raw_ptr()->identifier_; }
   void set_identifier(const String& value) const;
 
   // The resolved constructor or factory target of the redirection.
   RawFunction* target() const { return raw_ptr()->target_; }
   void set_target(const Function& value) const;
 
   static RawRedirectionData* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(RedirectionData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
-
 class Field : public Object {
  public:
   RawField* Original() const;
   void SetOriginal(const Field& value) const;
   bool IsOriginal() const {
     if (IsNull()) {
       return true;
     }
     NoSafepointScope no_safepoint;
     return !raw_ptr()->owner_->IsField();
@@ skipping 36 matching lines @@
     return raw_ptr()->kernel_offset_;
 #endif
   }
 
   void set_kernel_offset(intptr_t kernel_offset) const {
 #if !defined(DART_PRECOMPILED_RUNTIME)
     StoreNonPointer(&raw_ptr()->kernel_offset_, kernel_offset);
 #endif
   }
 
-
   inline intptr_t Offset() const;
   // Called during class finalization.
   inline void SetOffset(intptr_t offset_in_bytes) const;
 
   inline RawInstance* StaticValue() const;
   inline void SetStaticValue(const Instance& value,
                              bool save_initial_value = false) const;
 
   RawClass* Owner() const;
   RawClass* Origin() const;  // Either mixin class, or same as owner().
@@ skipping 249 matching lines @@
 
   static RawField* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
   friend class HeapProfiler;
   friend class RawField;
   friend class FieldSerializationCluster;
 };
 
-
 class LiteralToken : public Object {
  public:
   Token::Kind kind() const { return raw_ptr()->kind_; }
   RawString* literal() const { return raw_ptr()->literal_; }
   RawObject* value() const { return raw_ptr()->value_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLiteralToken));
   }
 
   static RawLiteralToken* New();
   static RawLiteralToken* New(Token::Kind kind, const String& literal);
 
  private:
   void set_kind(Token::Kind kind) const {
     StoreNonPointer(&raw_ptr()->kind_, kind);
   }
   void set_literal(const String& literal) const;
   void set_value(const Object& value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LiteralToken, Object);
   friend class Class;
 };
 
-
 class TokenStream : public Object {
  public:
   RawGrowableObjectArray* TokenObjects() const;
   void SetTokenObjects(const GrowableObjectArray& value) const;
 
   RawExternalTypedData* GetStream() const;
   void SetStream(const ExternalTypedData& stream) const;
 
   RawString* GenerateSource() const;
   RawString* GenerateSource(TokenPosition start, TokenPosition end) const;
@@ skipping 68 matching lines @@
 
   static RawTokenStream* New();
   static void DataFinalizer(void* isolate_callback_data,
                             Dart_WeakPersistentHandle handle,
                             void* peer);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
-
 class Script : public Object {
  public:
   RawString* url() const { return raw_ptr()->url_; }
 
   // The actual url which was loaded from disk, if provided by the embedder.
   RawString* resolved_url() const { return raw_ptr()->resolved_url_; }
   bool HasSource() const;
   RawString* Source() const;
   RawString* GenerateSource() const;  // Generates source code from Tokenstream.
   RawGrowableObjectArray* GenerateLineNumberArray() const;
@@ skipping 102 matching lines @@
   RawArray* line_starts() const;
   RawArray* debug_positions() const;
 
   static RawScript* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Script, Object);
   friend class Class;
   friend class Precompiler;
 };
 
-
 class DictionaryIterator : public ValueObject {
  public:
   explicit DictionaryIterator(const Library& library);
 
   bool HasNext() const { return next_ix_ < size_; }
 
   // Returns next non-null raw object.
   RawObject* GetNext();
 
  private:
   void MoveToNextObject();
 
   const Array& array_;
   const int size_;  // Number of elements to iterate over.
   int next_ix_;     // Index of next element.
 
   friend class ClassDictionaryIterator;
   friend class LibraryPrefixIterator;
   DISALLOW_COPY_AND_ASSIGN(DictionaryIterator);
 };
 
-
 class ClassDictionaryIterator : public DictionaryIterator {
  public:
   enum IterationKind {
     // TODO(hausner): fix call sites that use kIteratePrivate. There is only
     // one top-level class per library left, not an array to iterate over.
     kIteratePrivate,
     kNoIteratePrivate
   };
 
   ClassDictionaryIterator(const Library& library,
                           IterationKind kind = kNoIteratePrivate);
 
   bool HasNext() const {
     return (next_ix_ < size_) || !toplevel_class_.IsNull();
   }
 
   // Returns a non-null raw class.
   RawClass* GetNextClass();
 
  private:
   void MoveToNextClass();
 
   Class& toplevel_class_;
 
   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
 };
 
-
 class LibraryPrefixIterator : public DictionaryIterator {
  public:
   explicit LibraryPrefixIterator(const Library& library);
   RawLibraryPrefix* GetNext();
 
  private:
   void Advance();
   DISALLOW_COPY_AND_ASSIGN(LibraryPrefixIterator);
 };
 
-
 class Library : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   void SetName(const String& name) const;
 
   RawString* url() const { return raw_ptr()->url_; }
   RawString* private_key() const { return raw_ptr()->private_key_; }
   bool LoadNotStarted() const {
     return raw_ptr()->load_state_ == RawLibrary::kAllocated;
   }
@@ skipping 186 matching lines @@
   static void CheckFunctionFingerprints();
 #endif  // defined(DART_NO_SNAPSHOT).
 
   static bool IsPrivate(const String& name);
   // Construct the full name of a corelib member.
   static const String& PrivateCoreLibName(const String& member);
   // Lookup class in the core lib which also contains various VM
   // helper methods and classes. Allow look up of private classes.
   static RawClass* LookupCoreClass(const String& class_name);
 
-
   // Return Function::null() if function does not exist in libs.
   static RawFunction* GetFunction(const GrowableArray<Library*>& libs,
                                   const char* class_name,
                                   const char* function_name);
 
   // Character used to indicate a private identifier.
   static const char kPrivateIdentifierStart = '_';
 
   // Character used to separate private identifiers from
   // the library-specific key.
@@ skipping 28 matching lines @@
   void InvalidateResolvedName(const String& name) const;
   void InvalidateResolvedNamesCache() const;
 
   RawArray* exported_names() const { return raw_ptr()->exported_names_; }
   bool LookupExportedNamesCache(const String& name, Object* obj) const;
   void AddToExportedNamesCache(const String& name, const Object& obj) const;
   void InitExportedNamesCache() const;
   void ClearExportedNamesCache() const;
   static void InvalidateExportedNamesCaches();
 
-
   void InitImportList() const;
   void RehashDictionary(const Array& old_dict, intptr_t new_dict_size) const;
   static RawLibrary* NewLibraryHelper(const String& url, bool import_core_lib);
   RawObject* LookupEntry(const String& name, intptr_t* index) const;
 
   void AllocatePrivateKey() const;
 
   RawString* MakeMetadataName(const Object& obj) const;
   RawField* GetMetadataField(const String& metaname) const;
   void AddMetadata(const Object& owner,
                    const String& name,
                    TokenPosition token_pos,
                    intptr_t kernel_offset = 0) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
 
   friend class Bootstrap;
   friend class Class;
   friend class Debugger;
   friend class DictionaryIterator;
   friend class Isolate;
   friend class LibraryDeserializationCluster;
   friend class Namespace;
   friend class Object;
   friend class Precompiler;
 };
 
-
 // A Namespace contains the names in a library dictionary, filtered by
 // the show/hide combinators.
 class Namespace : public Object {
  public:
   RawLibrary* library() const { return raw_ptr()->library_; }
   RawArray* show_names() const { return raw_ptr()->show_names_; }
   RawArray* hide_names() const { return raw_ptr()->hide_names_; }
 
   void AddMetadata(const Object& owner, TokenPosition token_pos);
   RawObject* GetMetadata() const;
@@ skipping 13 matching lines @@
  private:
   static RawNamespace* New();
 
   RawField* metadata_field() const { return raw_ptr()->metadata_field_; }
   void set_metadata_field(const Field& value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
   friend class Class;
 };
 
-
 // ObjectPool contains constants, immediates and addresses embedded in code
 // and deoptimization infos. Each entry has an type-info associated with it
 // which is stored in a typed data array (info_array).
 class ObjectPool : public Object {
  public:
   enum EntryType {
     kTaggedObject,
     kImmediate,
     kNativeEntry,
   };
@@ skipping 84 matching lines @@
     ASSERT((index >= 0) && (index < Length()));
     return &raw_ptr()->data()[index];
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ObjectPool, Object);
   friend class Class;
   friend class Object;
   friend class RawObjectPool;
 };
 
-
 class Instructions : public Object {
  public:
   enum {
     kSizePos = 0,
     kSizeSize = 31,
     kFlagsPos = kSizePos + kSizeSize,
     kFlagsSize = 1,  // Currently, only flag is single entry flag.
   };
 
   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
@@ skipping 107 matching lines @@
   // and links the two in a GC safe manner.
   static RawInstructions* New(intptr_t size, bool has_single_entry_point);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
   friend class Class;
   friend class Code;
   friend class AssemblyImageWriter;
   friend class BlobImageWriter;
 };
 
-
 class LocalVarDescriptors : public Object {
  public:
   intptr_t Length() const;
 
   RawString* GetName(intptr_t var_index) const;
 
   void SetVar(intptr_t var_index,
               const String& name,
               RawLocalVarDescriptors::VarInfo* info) const;
 
@@ skipping 19 matching lines @@
   static RawLocalVarDescriptors* New(intptr_t num_variables);
 
   static const char* KindToCString(RawLocalVarDescriptors::VarInfoKind kind);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors, Object);
   friend class Class;
   friend class Object;
 };
 
-
 class PcDescriptors : public Object {
  public:
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kMaxInt32 / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawPcDescriptors) ==
            OFFSET_OF_RETURNED_VALUE(RawPcDescriptors, data));
     return 0;
   }
@@ skipping 102 matching lines @@
   static RawPcDescriptors* New(intptr_t length);
 
   void SetLength(intptr_t value) const;
   void CopyData(GrowableArray<uint8_t>* data);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors, Object);
   friend class Class;
   friend class Object;
 };
 
-
 class CodeSourceMap : public Object {
  public:
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kMaxInt32 / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawCodeSourceMap) ==
            OFFSET_OF_RETURNED_VALUE(RawCodeSourceMap, data));
     return 0;
   }
@@ skipping 20 matching lines @@
   void PrintToJSONObject(JSONObject* jsobj, bool ref) const;
 
  private:
   void SetLength(intptr_t value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(CodeSourceMap, Object);
   friend class Class;
   friend class Object;
 };
 
-
 class StackMap : public Object {
  public:
   static const intptr_t kNoMaximum = -1;
   static const intptr_t kNoMinimum = -1;
 
   bool IsObject(intptr_t index) const {
     ASSERT(InRange(index));
     return GetBit(index);
   }
 
@@ skipping 47 matching lines @@
   bool InRange(intptr_t index) const { return index < Length(); }
 
   bool GetBit(intptr_t bit_index) const;
   void SetBit(intptr_t bit_index, bool value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(StackMap, Object);
   friend class BitmapBuilder;
   friend class Class;
 };
 
-
 class ExceptionHandlers : public Object {
  public:
   static const intptr_t kInvalidPcOffset = 0;
 
   intptr_t num_entries() const;
 
   void GetHandlerInfo(intptr_t try_index, ExceptionHandlerInfo* info) const;
 
   uword HandlerPCOffset(intptr_t try_index) const;
   intptr_t OuterTryIndex(intptr_t try_index) const;
@@ skipping 34 matching lines @@
   // malicious code.
   static const intptr_t kMaxHandlers = 1024 * 1024;
 
   void set_handled_types_data(const Array& value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
   friend class Class;
   friend class Object;
 };
 
-
 class Code : public Object {
  public:
   RawInstructions* active_instructions() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->active_instructions_;
 #endif
   }
@@ skipping 157 matching lines @@
       kNumberOfEntries
     };
 
     const Array& comments_;
 
     friend class Code;
 
     DISALLOW_COPY_AND_ASSIGN(Comments);
   };
 
-
   const Comments& comments() const;
   void set_comments(const Comments& comments) const;
 
   RawObject* return_address_metadata() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->return_address_metadata_;
 #endif
@@ skipping 221 matching lines @@
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawCode* New(intptr_t pointer_offsets_length);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Code, Object);
   friend class Class;
   friend class SnapshotWriter;
   friend class FunctionSerializationCluster;
   friend class CodeSerializationCluster;
-  friend class CodePatcher;  // for set_instructions
+  friend class CodePatcher;     // for set_instructions
   friend class ProgramVisitor;  // for set_instructions
   // So that the RawFunction pointer visitor can determine whether code the
   // function points to is optimized.
   friend class RawFunction;
 };
 
-
 class Context : public Object {
  public:
   RawContext* parent() const { return raw_ptr()->parent_; }
   void set_parent(const Context& parent) const {
     StorePointer(&raw_ptr()->parent_, parent.raw());
   }
   static intptr_t parent_offset() { return OFFSET_OF(RawContext, parent_); }
 
   intptr_t num_variables() const { return raw_ptr()->num_variables_; }
   static intptr_t num_variables_offset() {
@@ skipping 36 matching lines @@
 
   void set_num_variables(intptr_t num_variables) const {
     StoreNonPointer(&raw_ptr()->num_variables_, num_variables);
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Context, Object);
   friend class Class;
   friend class Object;
 };
 
-
 // The ContextScope class makes it possible to delay the compilation of a local
 // function until it is invoked. A ContextScope instance collects the local
 // variables that are referenced by the local function to be compiled and that
 // belong to the outer scopes, that is, to the local scopes of (possibly nested)
 // functions enclosing the local function. Each captured variable is represented
 // by its token position in the source, its name, its type, its allocation index
 // in the context, and its context level. The function nesting level and loop
 // nesting level are not preserved, since they are only used until the context
 // level is assigned. In addition the ContextScope has a field 'is_implicit'
 // which is true if the ContextScope was created for an implicit closure.
@@ skipping 59 matching lines @@
   const RawContextScope::VariableDesc* VariableDescAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < num_variables()));
     return raw_ptr()->VariableDescAddr(index);
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ContextScope, Object);
   friend class Class;
   friend class Object;
 };
 
-
 class MegamorphicCache : public Object {
  public:
   static const intptr_t kInitialCapacity = 16;
   static const intptr_t kSpreadFactor = 7;
   static const double kLoadFactor;
 
   RawArray* buckets() const;
   void set_buckets(const Array& buckets) const;
 
   intptr_t mask() const;
@@ skipping 48 matching lines @@
                               const Smi& class_id,
                               const Function& target);
 
   static inline RawObject* GetClassId(const Array& array, intptr_t index);
   static inline RawObject* GetTargetFunction(const Array& array,
                                              intptr_t index);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache, Object);
 };
 
-
 class SubtypeTestCache : public Object {
  public:
   enum Entries {
     kInstanceClassIdOrFunction = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
     kFunctionTypeArguments = 3,
     kTestResult = 4,
     kTestEntryLength = 5,
   };
@@ skipping 25 matching lines @@
   RawArray* cache() const { return raw_ptr()->cache_; }
 
   void set_cache(const Array& value) const;
 
   intptr_t TestEntryLength() const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache, Object);
   friend class Class;
 };
 
-
 class Error : public Object {
  public:
   virtual const char* ToErrorCString() const;
 
  private:
   HEAP_OBJECT_IMPLEMENTATION(Error, Object);
 };
 
-
 class ApiError : public Error {
  public:
   RawString* message() const { return raw_ptr()->message_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawApiError));
   }
 
   static RawApiError* New(const String& message,
                           Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_message(const String& message) const;
 
   static RawApiError* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ApiError, Error);
   friend class Class;
 };
 
-
 class LanguageError : public Error {
  public:
   Report::Kind kind() const {
     return static_cast<Report::Kind>(raw_ptr()->kind_);
   }
 
   // Build, cache, and return formatted message.
   RawString* FormatMessage() const;
 
   static intptr_t InstanceSize() {
@@ skipping 46 matching lines @@
 
   RawString* formatted_message() const { return raw_ptr()->formatted_message_; }
   void set_formatted_message(const String& value) const;
 
   static RawLanguageError* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LanguageError, Error);
   friend class Class;
 };
 
-
 class UnhandledException : public Error {
  public:
   RawInstance* exception() const { return raw_ptr()->exception_; }
   static intptr_t exception_offset() {
     return OFFSET_OF(RawUnhandledException, exception_);
   }
 
   RawInstance* stacktrace() const { return raw_ptr()->stacktrace_; }
   static intptr_t stacktrace_offset() {
     return OFFSET_OF(RawUnhandledException, stacktrace_);
@@ skipping 13 matching lines @@
   static RawUnhandledException* New(Heap::Space space = Heap::kNew);
 
   void set_exception(const Instance& exception) const;
   void set_stacktrace(const Instance& stacktrace) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnhandledException, Error);
   friend class Class;
   friend class ObjectStore;
 };
 
-
 class UnwindError : public Error {
  public:
   bool is_user_initiated() const { return raw_ptr()->is_user_initiated_; }
   void set_is_user_initiated(bool value) const;
 
   RawString* message() const { return raw_ptr()->message_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnwindError));
   }
 
   static RawUnwindError* New(const String& message,
                              Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_message(const String& message) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnwindError, Error);
   friend class Class;
 };
 
-
 // Instance is the base class for all instance objects (aka the Object class
 // in Dart source code.
 class Instance : public Object {
  public:
   // Equality and identity testing.
   // 1. OperatorEquals: true iff 'this == other' is true in Dart code.
   // 2. IsIdenticalTo: true iff 'identical(this, other)' is true in Dart code.
   // 3. CanonicalizeEquals: used to canonicalize compile-time constants, e.g.,
   //    using bitwise equality of fields and list elements.
   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
@@ skipping 135 matching lines @@
   friend class RegExp;
   friend class SnapshotWriter;
   friend class StubCode;
   friend class TypedDataView;
   friend class InstanceSerializationCluster;
   friend class InstanceDeserializationCluster;
   friend class ClassDeserializationCluster;  // vtable
   friend class InstanceMorpher;
 };
 
-
 class LibraryPrefix : public Instance {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   virtual RawString* DictionaryName() const { return name(); }
 
   RawArray* imports() const { return raw_ptr()->imports_; }
   intptr_t num_imports() const { return raw_ptr()->num_imports_; }
   RawLibrary* importer() const { return raw_ptr()->importer_; }
 
   RawInstance* LoadError() const;
@@ skipping 36 matching lines @@
   void set_num_imports(intptr_t value) const;
   void set_importer(const Library& value) const;
   void set_is_loaded() const;
 
   static RawLibraryPrefix* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Instance);
   friend class Class;
 };
 
-
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Instance {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   virtual bool IsFinalized() const;
@@ skipping 188 matching lines @@
   // type arguments, if any.
   RawString* BuildName(NameVisibility visibility) const;
 
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Instance);
   friend class Class;
   friend class Function;
   friend class TypeArguments;
 };
 
-
 // A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
 // opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does not
 // relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
 class Type : public AbstractType {
  public:
   static intptr_t type_class_id_offset() {
@@ skipping 131 matching lines @@
   void set_type_state(int8_t state) const;
 
   static RawType* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
   friend class TypeArguments;
   friend class ClearTypeHashVisitor;
 };
 
-
 // A TypeRef is used to break cycles in the representation of recursive types.
 // Its only field is the recursive AbstractType it refers to, which can
 // temporarily be null during finalization.
 // Note that the cycle always involves type arguments.
 class TypeRef : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     const AbstractType& ref_type = AbstractType::Handle(type());
     return !ref_type.IsNull() && ref_type.IsFinalized();
   }
@@ skipping 54 matching lines @@
 
   static RawTypeRef* New(const AbstractType& type);
 
  private:
   static RawTypeRef* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeRef, AbstractType);
   friend class Class;
 };
 
-
 // A TypeParameter represents a type parameter of a parameterized class.
 // It specifies its index (and its name for debugging purposes), as well as its
 // upper bound.
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
 // Upon finalization, the TypeParameter index is changed to reflect its position
 // as type argument (rather than type parameter) of the parameterized class.
 // If the type parameter is declared without an extends clause, its bound is set
 // to the ObjectType.
@@ skipping 84 matching lines @@
   void set_token_pos(TokenPosition token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
   friend class ClearTypeHashVisitor;
 };
 
-
 // A BoundedType represents a type instantiated at compile time from a type
 // parameter specifying a bound that either cannot be checked at compile time
 // because the type or the bound are still uninstantiated or can be checked and
 // would trigger a bound error in checked mode. The bound must be checked at
 // runtime once the type and its bound are instantiated and when the execution
 // mode is known to be checked mode.
 class BoundedType : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     return AbstractType::Handle(type()).IsFinalized();
@@ skipping 75 matching lines @@
   void set_bound(const AbstractType& value) const;
   void set_type_parameter(const TypeParameter& value) const;
 
   static RawBoundedType* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(BoundedType, AbstractType);
   friend class Class;
   friend class ClearTypeHashVisitor;
 };
 
-
 // A MixinAppType represents a parsed mixin application clause, e.g.
 // "S<T> with M<U>, N<V>".
 // MixinAppType objects do not survive finalization, so they do not
 // need to be written to and read from snapshots.
 // The class finalizer creates synthesized classes S&M and S&M&N if they do not
 // yet exist in the library declaring the mixin application clause.
 class MixinAppType : public AbstractType {
  public:
   // A MixinAppType object is unfinalized by definition, since it is replaced at
   // class finalization time with a finalized (and possibly malformed or
@@ skipping 31 matching lines @@
 
   RawArray* mixin_types() const { return raw_ptr()->mixin_types_; }
   void set_mixin_types(const Array& value) const;
 
   static RawMixinAppType* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MixinAppType, AbstractType);
   friend class Class;
 };
 
-
 class Number : public Instance {
  public:
   // TODO(iposva): Add more useful Number methods.
   RawString* ToString(Heap::Space space) const;
 
   // Numbers are canonicalized differently from other instances/strings.
   virtual RawInstance* CheckAndCanonicalize(Thread* thread,
                                             const char** error_str) const;
 
 #if defined(DEBUG)
   // Check if number is canonical.
   virtual bool CheckIsCanonical(Thread* thread) const;
 #endif  // DEBUG
 
  private:
   OBJECT_IMPLEMENTATION(Number, Instance);
 
   friend class Class;
 };
 
-
 class Integer : public Number {
  public:
   static RawInteger* New(const String& str, Heap::Space space = Heap::kNew);
   static RawInteger* NewFromUint64(uint64_t value,
                                    Heap::Space space = Heap::kNew);
 
   // Returns a canonical Integer object allocated in the old gen space.
   static RawInteger* NewCanonical(const String& str);
 
   static RawInteger* New(int64_t value, Heap::Space space = Heap::kNew);
@@ skipping 34 matching lines @@
                            Heap::Space space = Heap::kNew) const;
   RawInteger* BitOp(Token::Kind operation,
                     const Integer& other,
                     Heap::Space space = Heap::kNew) const;
 
  private:
   OBJECT_IMPLEMENTATION(Integer, Number);
   friend class Class;
 };
 
-
 class Smi : public Integer {
  public:
   static const intptr_t kBits = kSmiBits;
   static const intptr_t kMaxValue = kSmiMax;
   static const intptr_t kMinValue = kSmiMin;
 
   intptr_t Value() const { return ValueFromRaw(raw_value()); }
 
   virtual bool Equals(const Instance& other) const;
   virtual bool IsZero() const { return Value() == 0; }
@@ skipping 64 matching lines @@
   Smi() : Integer() {}
   BASE_OBJECT_IMPLEMENTATION(Smi, Integer);
   OBJECT_SERVICE_SUPPORT(Smi);
   friend class Api;  // For ValueFromRaw
   friend class Class;
   friend class Object;
   friend class ReusableSmiHandleScope;
   friend class Thread;
 };
 
-
 class Mint : public Integer {
  public:
   static const intptr_t kBits = 63;  // 64-th bit is sign.
   static const int64_t kMaxValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x7FFFFFFF, FFFFFFFF));
   static const int64_t kMinValue =
       static_cast<int64_t>(DART_2PART_UINT64_C(0x80000000, 00000000));
 
   int64_t value() const { return raw_ptr()->value_; }
   static intptr_t value_offset() { return OFFSET_OF(RawMint, value_); }
@@ skipping 24 matching lines @@
   static RawMint* NewCanonical(int64_t value);
 
  private:
   void set_value(int64_t value) const;
 
   MINT_OBJECT_IMPLEMENTATION(Mint, Integer, Integer);
   friend class Class;
   friend class Number;
 };
 
-
 class Bigint : public Integer {
  public:
   virtual bool IsZero() const { return Used() == 0; }
   virtual bool IsNegative() const { return Neg(); }
   virtual bool Equals(const Instance& other) const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
   virtual int64_t AsTruncatedInt64Value() const;
   virtual uint32_t AsTruncatedUint32Value() const;
@@ skipping 77 matching lines @@
   static RawTypedData* NewDigitsFromDecCString(const char* str,
                                                intptr_t* used,
                                                Heap::Space space = Heap::kNew);
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
   friend class Class;
 };
 
-
 // Class Double represents class Double in corelib_impl, which implements
 // abstract class double in corelib.
 class Double : public Number {
  public:
   double value() const { return raw_ptr()->value_; }
 
   bool BitwiseEqualsToDouble(double value) const;
   virtual bool OperatorEquals(const Instance& other) const;
   virtual bool CanonicalizeEquals(const Instance& other) const;
   virtual uword ComputeCanonicalTableHash() const {
@@ skipping 20 matching lines @@
   static intptr_t value_offset() { return OFFSET_OF(RawDouble, value_); }
 
  private:
   void set_value(double value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Double, Number);
   friend class Class;
   friend class Number;
 };
 
-
 // String may not be '\0' terminated.
 class String : public Instance {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   static const intptr_t kOneByteChar = 1;
   static const intptr_t kTwoByteChar = 2;
 
-  // All strings share the same maximum element count to keep things
-  // simple.  We choose a value that will prevent integer overflow for
-  // 2 byte strings, since it is the worst case.
+// All strings share the same maximum element count to keep things
+// simple.  We choose a value that will prevent integer overflow for
+// 2 byte strings, since it is the worst case.
 #if defined(HASH_IN_OBJECT_HEADER)
   static const intptr_t kSizeofRawString = sizeof(RawInstance) + kWordSize;
 #else
   static const intptr_t kSizeofRawString = sizeof(RawInstance) + 2 * kWordSize;
 #endif
   static const intptr_t kMaxElements = kSmiMax / kTwoByteChar;
 
   class CodePointIterator : public ValueObject {
    public:
     explicit CodePointIterator(const String& str)
@@ skipping 313 matching lines @@
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   // So that SkippedCodeFunctions can print a debug string from a NoHandleScope.
   friend class SkippedCodeFunctions;
   friend class RawOneByteString;
   friend class RODataSerializationCluster;  // SetHash
 };
 
-
 class OneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
     return raw_ptr(str)->data()[index];
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint8_t code_unit) {
     NoSafepointScope no_safepoint;
@@ skipping 116 matching lines @@
                                     bool as_reference);
 
   friend class Class;
   friend class String;
   friend class Symbols;
   friend class ExternalOneByteString;
   friend class SnapshotReader;
   friend class StringHasher;
 };
 
-
 class TwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     return raw_ptr(str)->data()[index];
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint16_t ch) {
     NoSafepointScope no_safepoint;
@@ skipping 66 matching lines @@
                       Dart_PeerFinalizer cback);
 
   static void Finalize(void* isolate_callback_data,
                        Dart_WeakPersistentHandle handle,
                        void* peer);
 
   static RawTwoByteString* null() {
     return reinterpret_cast<RawTwoByteString*>(Object::null());
   }
 
-
   static const ClassId kClassId = kTwoByteStringCid;
 
  private:
   static RawTwoByteString* raw(const String& str) {
     return reinterpret_cast<RawTwoByteString*>(str.raw());
   }
 
   static const RawTwoByteString* raw_ptr(const String& str) {
     return reinterpret_cast<const RawTwoByteString*>(str.raw_ptr());
   }
 
   static uint16_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
     return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
   static RawTwoByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
 };
 
-
 class ExternalOneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     NoSafepointScope no_safepoint;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
@@ skipping 63 matching lines @@
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
 };
 
-
 class ExternalTwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
     NoSafepointScope no_safepoint;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
@@ skipping 59 matching lines @@
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
   friend class Symbols;
 };
 
-
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
   bool value() const { return raw_ptr()->value_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawBool));
   }
 
   static const Bool& True() { return Object::bool_true(); }
@@ skipping 10 matching lines @@
   }
 
   // New should only be called to initialize the two legal bool values.
   static RawBool* New(bool value);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bool, Instance);
   friend class Class;
   friend class Object;  // To initialize the true and false values.
 };
 
-
 class Array : public Instance {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 103 matching lines @@
     StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Array, Instance);
   friend class Class;
   friend class ImmutableArray;
   friend class Object;
   friend class String;
 };
 
-
 class ImmutableArray : public AllStatic {
  public:
   static RawImmutableArray* New(intptr_t len, Heap::Space space = Heap::kNew);
 
   static RawImmutableArray* ReadFrom(SnapshotReader* reader,
                                      intptr_t object_id,
                                      intptr_t tags,
                                      Snapshot::Kind kind,
                                      bool as_reference);
 
@@ skipping 11 matching lines @@
     return -kWordSize;
   }
 
   static RawImmutableArray* raw(const Array& array) {
     return reinterpret_cast<RawImmutableArray*>(array.raw());
   }
 
   friend class Class;
 };
 
-
 class GrowableObjectArray : public Instance {
  public:
   intptr_t Capacity() const {
     NoSafepointScope no_safepoint;
     ASSERT(!IsNull());
     return Smi::Value(DataArray()->length_);
   }
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 87 matching lines @@
     return &(DataArray()->data()[index]);
   }
 
   static const int kDefaultInitialCapacity = 0;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
-
 class Float32x4 : public Instance {
  public:
   static RawFloat32x4* New(float value0,
                            float value1,
                            float value2,
                            float value3,
                            Heap::Space space = Heap::kNew);
   static RawFloat32x4* New(simd128_value_t value,
                            Heap::Space space = Heap::kNew);
 
@@ skipping 14 matching lines @@
     return RoundedAllocationSize(sizeof(RawFloat32x4));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawFloat32x4, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float32x4, Instance);
   friend class Class;
 };
 
-
 class Int32x4 : public Instance {
  public:
   static RawInt32x4* New(int32_t value0,
                          int32_t value1,
                          int32_t value2,
                          int32_t value3,
                          Heap::Space space = Heap::kNew);
   static RawInt32x4* New(simd128_value_t value, Heap::Space space = Heap::kNew);
 
   int32_t x() const;
@@ skipping 13 matching lines @@
     return RoundedAllocationSize(sizeof(RawInt32x4));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawInt32x4, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Int32x4, Instance);
   friend class Class;
 };
 
-
 class Float64x2 : public Instance {
  public:
   static RawFloat64x2* New(double value0,
                            double value1,
                            Heap::Space space = Heap::kNew);
   static RawFloat64x2* New(simd128_value_t value,
                            Heap::Space space = Heap::kNew);
 
   double x() const;
   double y() const;
 
   void set_x(double x) const;
   void set_y(double y) const;
 
   simd128_value_t value() const;
   void set_value(simd128_value_t value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFloat64x2));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawFloat64x2, value_); }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float64x2, Instance);
   friend class Class;
 };
 
-
 class TypedData : public Instance {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 98 matching lines @@
                              dst.LengthInBytes()));
     {
       NoSafepointScope no_safepoint;
       if (length_in_bytes > 0) {
         memmove(dst.DataAddr(dst_offset_in_bytes),
                 src.DataAddr(src_offset_in_bytes), length_in_bytes);
       }
     }
   }
 
-
   template <typename DstType, typename SrcType>
   static void ClampedCopy(const DstType& dst,
                           intptr_t dst_offset_in_bytes,
                           const SrcType& src,
                           intptr_t src_offset_in_bytes,
                           intptr_t length_in_bytes) {
     ASSERT(Utils::RangeCheck(src_offset_in_bytes, length_in_bytes,
                              src.LengthInBytes()));
     ASSERT(Utils::RangeCheck(dst_offset_in_bytes, length_in_bytes,
                              dst.LengthInBytes()));
@@ skipping 38 matching lines @@
   static const intptr_t kNumElementSizes =
       kTypedDataFloat64x2ArrayCid - kTypedDataInt8ArrayCid + 1;
   static const intptr_t element_size_table[kNumElementSizes];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypedData, Instance);
   friend class Class;
   friend class ExternalTypedData;
   friend class TypedDataView;
 };
 
-
 class ExternalTypedData : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   intptr_t ElementSizeInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return ElementSizeInBytes(cid);
@@ skipping 91 matching lines @@
     ASSERT(
         !Isolate::Current()->heap()->Contains(reinterpret_cast<uword>(data)));
     StoreNonPointer(&raw_ptr()->data_, data);
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData, Instance);
   friend class Class;
 };
 
-
 class TypedDataView : public AllStatic {
  public:
   static intptr_t ElementSizeInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
     intptr_t cid = view_obj.raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
@@ skipping 39 matching lines @@
   }
 
  private:
   enum {
     kDataOffset = 1,
     kOffsetInBytesOffset = 2,
     kLengthOffset = 3,
   };
 };
 
-
 class ByteBuffer : public AllStatic {
  public:
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
     return *reinterpret_cast<RawInstance* const*>(view_obj.raw_ptr() +
                                                   kDataOffset);
   }
 
   static intptr_t NumberOfFields() { return kDataOffset; }
 
   static intptr_t data_offset() { return kWordSize * kDataOffset; }
 
  private:
   enum {
     kDataOffset = 1,
   };
 };
 
-
 // Corresponds to
 // - "new Map()",
 // - non-const map literals, and
 // - the default constructor of LinkedHashMap in dart:collection.
 class LinkedHashMap : public Instance {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLinkedHashMap));
   }
 
@@ skipping 113 matching lines @@
   static const intptr_t kInitialIndexSize = 1 << (kInitialIndexBits + 1);
 
   // Allocate a map, but leave all fields set to null.
   // Used during deserialization (since map might contain itself as key/value).
   static RawLinkedHashMap* NewUninitialized(Heap::Space space = Heap::kNew);
 
   friend class Class;
   friend class LinkedHashMapDeserializationCluster;
 };
 
-
 class Closure : public Instance {
  public:
   RawTypeArguments* instantiator_type_arguments() const {
     return raw_ptr()->instantiator_type_arguments_;
   }
   static intptr_t instantiator_type_arguments_offset() {
     return OFFSET_OF(RawClosure, instantiator_type_arguments_);
   }
 
   RawTypeArguments* function_type_arguments() const {
@@ skipping 26 matching lines @@
                          const Context& context,
                          Heap::Space space = Heap::kNew);
 
  private:
   static RawClosure* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Closure, Instance);
   friend class Class;
 };
 
-
 class Capability : public Instance {
  public:
   uint64_t Id() const { return raw_ptr()->id_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawCapability));
   }
   static RawCapability* New(uint64_t id, Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Capability, Instance);
   friend class Class;
 };
 
-
 class ReceivePort : public Instance {
  public:
   RawSendPort* send_port() const { return raw_ptr()->send_port_; }
   Dart_Port Id() const { return send_port()->ptr()->id_; }
 
   RawInstance* handler() const { return raw_ptr()->handler_; }
   void set_handler(const Instance& value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawReceivePort));
   }
   static RawReceivePort* New(Dart_Port id,
                              bool is_control_port,
                              Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ReceivePort, Instance);
   friend class Class;
 };
 
-
 class SendPort : public Instance {
  public:
   Dart_Port Id() const { return raw_ptr()->id_; }
 
   Dart_Port origin_id() const { return raw_ptr()->origin_id_; }
   void set_origin_id(Dart_Port id) const {
     ASSERT(origin_id() == 0);
     StoreNonPointer(&(raw_ptr()->origin_id_), id);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSendPort));
   }
   static RawSendPort* New(Dart_Port id, Heap::Space space = Heap::kNew);
   static RawSendPort* New(Dart_Port id,
                           Dart_Port origin_id,
                           Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SendPort, Instance);
   friend class Class;
 };
 
-
 // Internal stacktrace object used in exceptions for printing stack traces.
 class StackTrace : public Instance {
  public:
   static const int kPreallocatedStackdepth = 30;
 
   intptr_t Length() const;
 
   RawStackTrace* async_link() const { return raw_ptr()->async_link_; }
   void set_async_link(const StackTrace& async_link) const;
   void set_expand_inlined(bool value) const;
@@ skipping 24 matching lines @@
 
   void set_code_array(const Array& code_array) const;
   void set_pc_offset_array(const Array& pc_offset_array) const;
   bool expand_inlined() const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(StackTrace, Instance);
   friend class Class;
   friend class Debugger;
 };
 
-
 // Internal JavaScript regular expression object.
 class RegExp : public Instance {
  public:
   // Meaning of RegExType:
   // kUninitialized: the type of th regexp has not been initialized yet.
   // kSimple: A simple pattern to match against, using string indexOf operation.
   // kComplex: A complex pattern to match.
   enum RegExType {
     kUnitialized = 0,
     kSimple = 1,
@@ skipping 120 matching lines @@
                     FlagsBits::update(value, raw_ptr()->type_flags_));
   }
 
   RegExType type() const { return TypeBits::decode(raw_ptr()->type_flags_); }
   intptr_t flags() const { return FlagsBits::decode(raw_ptr()->type_flags_); }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(RegExp, Instance);
   friend class Class;
 };
 
-
 class WeakProperty : public Instance {
  public:
   RawObject* key() const { return raw_ptr()->key_; }
 
   void set_key(const Object& key) const {
     StorePointer(&raw_ptr()->key_, key.raw());
   }
 
   RawObject* value() const { return raw_ptr()->value_; }
 
@@ skipping 11 matching lines @@
     ASSERT(raw_weak->ptr()->next_ == 0);
     raw_weak->StorePointer(&(raw_weak->ptr()->key_), Object::null());
     raw_weak->StorePointer(&(raw_weak->ptr()->value_), Object::null());
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
   friend class Class;
 };
 
-
 class MirrorReference : public Instance {
  public:
   RawObject* referent() const { return raw_ptr()->referent_; }
 
   void set_referent(const Object& referent) const {
     StorePointer(&raw_ptr()->referent_, referent.raw());
   }
 
   RawAbstractType* GetAbstractTypeReferent() const;
 
@@ skipping 12 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawMirrorReference));
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MirrorReference, Instance);
   friend class Class;
 };
 
-
 class UserTag : public Instance {
  public:
   uword tag() const { return raw_ptr()->tag(); }
   void set_tag(uword t) const {
     ASSERT(t >= UserTags::kUserTagIdOffset);
     ASSERT(t < UserTags::kUserTagIdOffset + UserTags::kMaxUserTags);
     StoreNonPointer(&raw_ptr()->tag_, t);
   }
   static intptr_t tag_offset() { return OFFSET_OF(RawUserTag, tag_); }
 
@@ skipping 16 matching lines @@
   static void AddTagToIsolate(Thread* thread, const UserTag& tag);
 
   void set_label(const String& tag_label) const {
     StorePointer(&raw_ptr()->label_, tag_label.raw());
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UserTag, Instance);
   friend class Class;
 };
 
-
 class ObjectPoolInfo : public ValueObject {
  public:
   explicit ObjectPoolInfo(const ObjectPool& pool)
       : array_(TypedData::Handle(pool.info_array())) {}
 
   explicit ObjectPoolInfo(const TypedData& info_array) : array_(info_array) {}
 
   ObjectPool::EntryType InfoAt(intptr_t i) {
     return static_cast<ObjectPool::EntryType>(array_.GetInt8(i));
   }
 
   void SetInfoAt(intptr_t i, ObjectPool::EntryType info) {
     array_.SetInt8(i, static_cast<int8_t>(info));
   }
 
  private:
   const TypedData& array_;
 };
 
-
 // Breaking cycles and loops.
 RawClass* Object::clazz() const {
   uword raw_value = reinterpret_cast<uword>(raw_);
   if ((raw_value & kSmiTagMask) == kSmiTag) {
     return Smi::Class();
   }
   return Isolate::Current()->class_table()->At(raw()->GetClassId());
 }
 
-
 DART_FORCE_INLINE void Object::SetRaw(RawObject* value) {
   NoSafepointScope no_safepoint_scope;
   raw_ = value;
   if ((reinterpret_cast<uword>(value) & kSmiTagMask) == kSmiTag) {
     set_vtable(Smi::handle_vtable_);
     return;
   }
   intptr_t cid = value->GetClassId();
   // Free-list elements cannot be wrapped in a handle.
   ASSERT(cid != kFreeListElement);
   ASSERT(cid != kForwardingCorpse);
   if (cid >= kNumPredefinedCids) {
     cid = kInstanceCid;
   }
   set_vtable(builtin_vtables_[cid]);
 #if defined(DEBUG)
   if (FLAG_verify_handles) {
     Isolate* isolate = Isolate::Current();
     Heap* isolate_heap = isolate->heap();
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(isolate_heap->Contains(RawObject::ToAddr(raw_)) ||
            vm_isolate_heap->Contains(RawObject::ToAddr(raw_)));
   }
 #endif
 }
 
-
 intptr_t Field::Offset() const {
   ASSERT(is_instance());  // Valid only for dart instance fields.
   intptr_t value = Smi::Value(raw_ptr()->value_.offset_);
   return (value * kWordSize);
 }
 
-
 void Field::SetOffset(intptr_t offset_in_bytes) const {
   ASSERT(is_instance());  // Valid only for dart instance fields.
   ASSERT(kWordSize != 0);
   StorePointer(&raw_ptr()->value_.offset_,
                Smi::New(offset_in_bytes / kWordSize));
 }
 
-
 RawInstance* Field::StaticValue() const {
   ASSERT(is_static());  // Valid only for static dart fields.
   return raw_ptr()->value_.static_value_;
 }
 
-
 void Field::SetStaticValue(const Instance& value,
                            bool save_initial_value) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   ASSERT(is_static());  // Valid only for static dart fields.
   StorePointer(&raw_ptr()->value_.static_value_, value.raw());
   if (save_initial_value) {
     ASSERT(!HasPrecompiledInitializer());
     StorePointer(&raw_ptr()->initializer_.saved_value_, value.raw());
   }
 }
 
-
 void Context::SetAt(intptr_t index, const Object& value) const {
   StorePointer(ObjectAddr(index), value.raw());
 }
 
-
 intptr_t Instance::GetNativeField(int index) const {
   ASSERT(IsValidNativeIndex(index));
   NoSafepointScope no_safepoint;
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     return 0;
   }
   return reinterpret_cast<intptr_t*>(native_fields->ptr()->data())[index];
 }
 
-
 void Instance::GetNativeFields(uint16_t num_fields,
                                intptr_t* field_values) const {
   NoSafepointScope no_safepoint;
   ASSERT(num_fields == NumNativeFields());
   ASSERT(field_values != NULL);
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     for (intptr_t i = 0; i < num_fields; i++) {
       field_values[i] = 0;
     }
   }
   intptr_t* fields = reinterpret_cast<intptr_t*>(native_fields->ptr()->data());
   for (intptr_t i = 0; i < num_fields; i++) {
     field_values[i] = fields[i];
   }
 }
 
-
 bool String::Equals(const String& str) const {
   if (raw() == str.raw()) {
     return true;  // Both handles point to the same raw instance.
   }
   if (str.IsNull()) {
     return false;
   }
   if (IsCanonical() && str.IsCanonical()) {
     return false;  // Two symbols that aren't identical aren't equal.
   }
   if (HasHash() && str.HasHash() && (Hash() != str.Hash())) {
     return false;  // Both sides have hash codes and they do not match.
   }
   return Equals(str, 0, str.Length());
 }
 
-
 intptr_t Library::UrlHash() const {
   intptr_t result = String::GetCachedHash(url());
   ASSERT(result != 0);
   return result;
 }
 
-
 void MegamorphicCache::SetEntry(const Array& array,
                                 intptr_t index,
                                 const Smi& class_id,
                                 const Function& target) {
   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
   array.SetAt((index * kEntryLength) + kTargetFunctionIndex, target);
 }
 
-
 RawObject* MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
   return array.At((index * kEntryLength) + kClassIdIndex);
 }
 
-
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
-
 inline intptr_t Type::Hash() const {
   intptr_t result = Smi::Value(raw_ptr()->hash_);
   if (result != 0) {
     return result;
   }
   return ComputeHash();
 }
 
-
 inline void Type::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
-
 inline intptr_t TypeParameter::Hash() const {
   ASSERT(IsFinalized());
   intptr_t result = Smi::Value(raw_ptr()->hash_);
   if (result != 0) {
     return result;
   }
   return ComputeHash();
 }
 
-
 inline void TypeParameter::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
-
 inline intptr_t BoundedType::Hash() const {
   intptr_t result = Smi::Value(raw_ptr()->hash_);
   if (result != 0) {
     return result;
   }
   return ComputeHash();
 }
 
-
 inline void BoundedType::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
-
 inline intptr_t TypeArguments::Hash() const {
   if (IsNull()) return 0;
   intptr_t result = Smi::Value(raw_ptr()->hash_);
   if (result != 0) {
     return result;
   }
   return ComputeHash();
 }
 
-
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_