Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

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 VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 21 matching lines @@
 class DeoptInstr;
 class LocalScope;
 class Symbols;
 
 #if defined(DEBUG)
 #define CHECK_HANDLE() CheckHandle();
 #else
 #define CHECK_HANDLE()
 #endif
 
-#define OBJECT_IMPLEMENTATION(object, super)                                   \
+#define BASE_OBJECT_IMPLEMENTATION(object, super)                              \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
-  void operator=(Raw##object* value) {                                         \
-    initializeHandle(this, value);                                             \
-  }                                                                            \
   bool Is##object() const { return true; }                                     \
-  void operator^=(RawObject* value) {                                          \
-    initializeHandle(this, value);                                             \
-    ASSERT(IsNull() || Is##object());                                          \
-  }                                                                            \
-  void operator|=(RawObject* value) {                                          \
-    raw_ = value;                                                              \
-    CHECK_HANDLE();                                                            \
-  }                                                                            \
   static object& Handle(Isolate* isolate, Raw##object* raw_ptr) {              \
     object* obj =                                                              \
         reinterpret_cast<object*>(VMHandles::AllocateHandle(isolate));         \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
   static object& Handle() {                                                    \
     return Handle(Isolate::Current(), object::null());                         \
   }                                                                            \
   static object& Handle(Isolate* isolate) {                                    \
@@ skipping 14 matching lines @@
   }                                                                            \
   static object& CheckedHandle(RawObject* raw_ptr) {                           \
     return CheckedHandle(Isolate::Current(), raw_ptr);                         \
   }                                                                            \
   static object& ZoneHandle(Isolate* isolate, Raw##object* raw_ptr) {          \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(isolate));                               \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
+  static object* ReadOnlyHandle(Isolate* isolate) {                            \
+    object* obj = reinterpret_cast<object*>(                                   \
+        Dart::AllocateReadOnlyHandle());                                       \
+    initializeHandle(obj, object::null());                                     \
+    return obj;                                                                \
+  }                                                                            \
   static object& ZoneHandle() {                                                \
     return ZoneHandle(Isolate::Current(), object::null());                     \
   }                                                                            \
   static object& ZoneHandle(Raw##object* raw_ptr) {                            \
     return ZoneHandle(Isolate::Current(), raw_ptr);                            \
   }                                                                            \
   static object& CheckedZoneHandle(Isolate* isolate, RawObject* raw_ptr) {     \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(isolate));                               \
     initializeHandle(obj, raw_ptr);                                            \
@@ skipping 12 matching lines @@
   static const object& Cast(const Object& obj) {                               \
     ASSERT(obj.Is##object());                                                  \
     return reinterpret_cast<const object&>(obj);                               \
   }                                                                            \
   static Raw##object* null() {                                                 \
     return reinterpret_cast<Raw##object*>(Object::null());                     \
   }                                                                            \
   virtual const char* ToCString() const;                                       \
   static const ClassId kClassId = k##object##Cid;                              \
  protected:  /* NOLINT */                                                      \
   object() : super() {}                                                        \

[Ivan Posva, 2013/01/23 03:44:20]

Can't we prevent subclassing of FINAL classes by marking their constructors
private?

[siva, 2013/01/23 19:26:53]

Done.

  private:  /* NOLINT */                                                        \
   /* Initialize the handle based on the raw_ptr in the presence of null. */    \
   static void initializeHandle(object* obj, RawObject* raw_ptr) {              \
     if (raw_ptr != Object::null()) {                                           \
       obj->SetRaw(raw_ptr);                                                    \
     } else {                                                                   \
       obj->raw_ = Object::null();                                              \
       object fake_object;                                                      \
       obj->set_vtable(fake_object.vtable());                                   \
     }                                                                          \
   }                                                                            \
   /* Disallow allocation, copy constructors and override super assignment. */  \
   void* operator new(size_t size);                                             \
   object(const object& value);                                                 \
   void operator=(Raw##super* value);                                           \
   void operator=(const object& value);                                         \
   void operator=(const super& value);                                          \
 
 #define SNAPSHOT_READER_SUPPORT(object)                                        \
   static Raw##object* ReadFrom(SnapshotReader* reader,                         \
                                intptr_t object_id,                             \
                                intptr_t tags,                                  \
                                Snapshot::Kind);                                \
   friend class SnapshotReader;                                                 \
 
+#define OBJECT_IMPLEMENTATION(object, super)                                   \
+ public:  /* NOLINT */                                                         \
+  void operator=(Raw##object* value) {                                         \
+    initializeHandle(this, value);                                             \
+  }                                                                            \
+  void operator^=(RawObject* value) {                                          \
+    initializeHandle(this, value);                                             \
+    ASSERT(IsNull() || Is##object());                                          \
+  }                                                                            \
+  BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
+
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class StackFrame;                                                     \
 
+// This macro is used to denote types that do not have a sub-type.
+#define FINAL_HEAP_OBJECT_IMPLEMENTATION(object, super)                        \
+ public:  /* NOLINT */                                                         \
+  void operator=(Raw##object* value) {                                         \
+    raw_ = value;                                                              \
+    CHECK_HANDLE();                                                            \
+  }                                                                            \
+  void operator^=(RawObject* value) {                                          \
+    raw_ = value;                                                              \
+    CHECK_HANDLE();                                                            \
+  }                                                                            \
+  BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
+  Raw##object* raw_ptr() const {                                               \
+    ASSERT(raw() != null());                                                   \
+    return raw()->ptr();                                                       \
+  }                                                                            \
+  SNAPSHOT_READER_SUPPORT(object)                                              \
+  friend class StackFrame;                                                     \
+
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) {
     initializeHandle(this, value);
   }
 
   void set_tags(intptr_t value) const {
@@ skipping 685 matching lines @@
                                                      const Script& script,
                                                      intptr_t token_pos);
 
   // Check the subtype or 'more specific' relationship.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& type_arguments,
                 const Class& other,
                 const AbstractTypeArguments& other_type_arguments,
                 Error* malformed_error) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Class, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class AbstractType;
   friend class Instance;
   friend class Object;
   friend class Type;
 };
 
 
 // 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 {
@@ skipping 13 matching lines @@
                                  const String& ident,
                                  intptr_t token_pos);
 
  private:
   void set_library_prefix(const LibraryPrefix& library_prefix) const;
   void set_ident(const String& ident) const;
   void set_token_pos(intptr_t token_pos) const;
 
   static RawUnresolvedClass* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and
 // InstantiatedTypeArguments.
 class AbstractTypeArguments : public Object {
  public:
   // Returns true if both arguments represent vectors of equal types.
@@ skipping 208 matching lines @@
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
 
   static RawPatchClass* New(const Class& patched_class, const Script& script);
 
  private:
   void set_patched_class(const Class& value) const;
   void set_script(const Script& value) const;
   static RawPatchClass* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
   friend class Class;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawString* UserVisibleName() const;
   RawString* QualifiedUserVisibleName() const;
   virtual RawString* DictionaryName() const { return name(); }
@@ skipping 457 matching lines @@
   // subtyping or 'more specific' relationship between the type of this function
   // and the type of the other function.
   bool TestParameterType(TypeTestKind test_kind,
                          intptr_t parameter_position,
                          intptr_t other_parameter_position,
                          const AbstractTypeArguments& type_arguments,
                          const Function& other,
                          const AbstractTypeArguments& other_type_arguments,
                          Error* malformed_error) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Function, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
 };
 
 
 class ClosureData: public Object {
  public:
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClosureData));
   }
 
@@ skipping 14 matching lines @@
   }
   void set_implicit_static_closure(const Instance& closure) const;
 
   RawCode* closure_allocation_stub() const {
     return raw_ptr()->closure_allocation_stub_;
   }
   void set_closure_allocation_stub(const Code& value) const;
 
   static RawClosureData* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(ClosureData, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ClosureData, 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();
 
-  HEAP_OBJECT_IMPLEMENTATION(RedirectionData, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(RedirectionData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
 
 class Field : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawString* UserVisibleName() const;
@@ skipping 73 matching lines @@
     StorePointer(&raw_ptr()->owner_, value.raw());
   }
   void set_token_pos(intptr_t token_pos) const {
     raw_ptr()->token_pos_ = token_pos;
   }
   void set_kind_bits(intptr_t value) const {
     raw_ptr()->kind_bits_ = static_cast<uint8_t>(value);
   }
   static RawField* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(Field, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
   friend class HeapProfiler;
 };
 
 
 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 { raw_ptr()->kind_ = kind; }
   void set_literal(const String& literal) const;
   void set_value(const Object& value) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(LiteralToken, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(LiteralToken, Object);
   friend class Class;
 };
 
 
 class TokenStream : public Object {
  public:
   RawArray* TokenObjects() const;
   void SetTokenObjects(const Array& value) const;
 
   RawExternalUint8Array* GetStream() const;
@@ skipping 57 matching lines @@
     Token::Kind cur_token_kind_;
     intptr_t cur_token_obj_index_;
   };
 
  private:
   void SetPrivateKey(const String& value) const;
 
   static RawTokenStream* New();
   static void DataFinalizer(void *peer);
 
-  HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
 
 class Script : public Object {
  public:
   RawString* url() const { return raw_ptr()->url_; }
   bool HasSource() const;
   RawString* Source() const;
   RawScript::Kind kind() const {
@@ skipping 30 matching lines @@
                         const String& source,
                         RawScript::Kind kind);
 
  private:
   void set_url(const String& value) const;
   void set_source(const String& value) const;
   void set_kind(RawScript::Kind value) const;
   void set_tokens(const TokenStream& value) const;
   static RawScript* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(Script, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Script, Object);
   friend class Class;
 };
 
 
 class DictionaryIterator : public ValueObject {
  public:
   explicit DictionaryIterator(const Library& library);
 
   bool HasNext() const { return next_ix_ < size_; }
 
@@ skipping 172 matching lines @@
   bool HasExports() const;
   RawArray* loaded_scripts() const { return raw_ptr()->loaded_scripts_; }
   RawArray* dictionary() const { return raw_ptr()->dictionary_; }
   void InitClassDictionary() const;
   void InitImportList() const;
   void GrowDictionary(const Array& dict, intptr_t dict_size) const;
   static RawLibrary* NewLibraryHelper(const String& url,
                                       bool import_core_lib);
   RawObject* LookupEntry(const String& name, intptr_t *index) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Library, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
   friend class Class;
   friend class Debugger;
   friend class DictionaryIterator;
   friend class Isolate;
   friend class Namespace;
 };
 
 
 class LibraryPrefix : public Object {
  public:
@@ skipping 16 matching lines @@
 
  private:
   static const int kInitialSize = 2;
   static const int kIncrementSize = 2;
 
   void set_name(const String& value) const;
   void set_imports(const Array& value) const;
   void set_num_imports(intptr_t value) const;
   static RawLibraryPrefix* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Object);
   friend class Class;
   friend class Isolate;
 };
 
 
 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_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawNamespace));
   }
 
   bool HidesName(const String& name) const;
   RawObject* Lookup(const String& name) const;
 
   static RawNamespace* New(const Library& library,
                            const Array& show_names,
                            const Array& hide_names);
  private:
   static RawNamespace* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
   friend class Class;
 };
 
 
 class Instructions : public Object {
  public:
   intptr_t size() const { return raw_ptr()->size_; }
   RawCode* code() const { return raw_ptr()->code_; }
 
   uword EntryPoint() const {
@@ skipping 35 matching lines @@
   void set_code(RawCode* code) {
     raw_ptr()->code_ = code;
   }
 
   // New is a private method as RawInstruction and RawCode objects should
   // 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 RawInstructions* New(intptr_t size);
 
-  HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
   friend class Class;
   friend class Code;
 };
 
 
 class LocalVarDescriptors : public Object {
  public:
   intptr_t Length() const;
 
   RawString* GetName(intptr_t var_index) const;
@@ skipping 15 matching lines @@
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawLocalVarDescriptors) + (len * kBytesPerElement));
   }
 
   static RawLocalVarDescriptors* New(intptr_t num_variables);
 
  private:
-  HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors, Object);
   friend class Class;
 };
 
 
 class PcDescriptors : public Object {
  private:
   // Describes the layout of PC descriptor data.
   enum {
     kPcEntry = 0,      // PC value of the descriptor, unique.
     kKindEntry = 1,
@@ skipping 77 matching lines @@
 
   intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
     return &raw_ptr()->data_[data_index];
   }
   RawSmi** SmiAddr(intptr_t index, intptr_t entry_offset) const {
     return reinterpret_cast<RawSmi**>(EntryAddr(index, entry_offset));
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(PcDescriptors, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors, Object);
   friend class Class;
 };
 
 
 class Stackmap : public Object {
  public:
   static const intptr_t kNoMaximum = -1;
   static const intptr_t kNoMinimum = -1;
 
   bool IsObject(intptr_t index) const {
@@ skipping 32 matching lines @@
                           intptr_t register_bit_count);
 
  private:
   void SetLength(intptr_t length) const { raw_ptr()->length_ = length; }
 
   bool InRange(intptr_t index) const { return index < Length(); }
 
   bool GetBit(intptr_t bit_index) const;
   void SetBit(intptr_t bit_index, bool value) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
   friend class BitmapBuilder;
   friend class Class;
 };
 
 
 class ExceptionHandlers : public Object {
  public:
   intptr_t Length() const;
 
   void GetHandlerInfo(intptr_t try_index,
@@ skipping 25 matching lines @@
   // We would have a VisitPointers function here to traverse the
   // exception handler table to visit objects if any in the table.
 
  private:
   // Pick somewhat arbitrary maximum number of exception handlers
   // for a function. This value is used to catch potentially
   // malicious code.
   static const intptr_t kMaxHandlers = 1024 * 1024;
 
   void set_handled_types_data(const Array& value) const;
-  HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
   friend class Class;
 };
 
 
 // Holds deopt information at one deoptimization point. The information
 // is a list of DeoptInstr objects, specifying transformation information
 // for each slot in unoptimized frame(s).
 class DeoptInfo : public Object {
  private:
   // Describes the layout of deopt info data. The index of a deopt-info entry
@@ skipping 46 matching lines @@
 
  private:
   intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
     return &raw_ptr()->data_[data_index];
   }
 
   void SetLength(intptr_t value) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
   friend class Class;
 };
 
 
 class Code : public Object {
  public:
   RawInstructions* instructions() const { return raw_ptr()->instructions_; }
   static intptr_t instructions_offset() {
     return OFFSET_OF(RawCode, instructions_);
   }
@@ skipping 212 matching lines @@
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
 
   // New is a private method as RawInstruction and RawCode objects should
   // 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);
 
-  HEAP_OBJECT_IMPLEMENTATION(Code, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Code, Object);
   friend class Class;
 };
 
 
 class Context : public Object {
  public:
   RawContext* parent() const { return raw_ptr()->parent_; }
   void set_parent(const Context& parent) const {
     ASSERT(parent.IsNull() || parent.isolate() == Isolate::Current());
     StorePointer(&raw_ptr()->parent_, parent.raw());
@@ skipping 40 matching lines @@
   }
 
   void set_isolate(Isolate* isolate) const {
     raw_ptr()->isolate_ = isolate;
   }
 
   void set_num_variables(intptr_t num_variables) const {
     raw_ptr()->num_variables_ = num_variables;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Context, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Context, Object);
   friend class Class;
 };
 
 
 // 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
@@ skipping 51 matching lines @@
   }
 
   RawContextScope::VariableDesc* VariableDescAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < num_variables()));
     uword raw_addr = reinterpret_cast<uword>(raw_ptr());
     raw_addr += sizeof(RawContextScope) +
         (index * sizeof(RawContextScope::VariableDesc));
     return reinterpret_cast<RawContextScope::VariableDesc*>(raw_addr);
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ContextScope, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ContextScope, Object);
   friend class Class;
 };
 
 
 // Object holding information about an IC: test classes and their
 // corresponding targets.
 class ICData : public Object {
  public:
   RawFunction* function() const {
     return raw_ptr()->function_;
@@ skipping 116 matching lines @@
   void set_ic_data(const Array& value) const;
 
 #if defined(DEBUG)
   // Used in asserts to verify that a check is not added twice.
   bool HasCheck(const GrowableArray<intptr_t>& cids) const;
 #endif  // DEBUG
 
   intptr_t TestEntryLength() const;
   void WriteSentinel() const;
 
-  HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
   friend class Class;
 };
 
 
 class MegamorphicCache : public Object {
  public:
   static const int kInitialCapacity = 16;
   static const double kLoadFactor;
 
   RawArray* buckets() const;
@@ skipping 33 matching lines @@
 
   static inline void SetEntry(const Array& array,
                               intptr_t index,
                               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);
 
-  HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache, Object);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache, Object);
 };
 
 
 class SubtypeTestCache : public Object {
  public:
   enum Entries {
     kInstanceClassId = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
     kTestResult = 3,
@@ skipping 23 matching lines @@
 
  private:
   RawArray* cache() const {
     return raw_ptr()->cache_;
   }
 
   void set_cache(const Array& value) const;
 
   intptr_t TestEntryLength() const;
 
-  HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache, Object);
+  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);
@@ skipping 13 matching lines @@
 
   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();
 
-  HEAP_OBJECT_IMPLEMENTATION(ApiError, Error);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ApiError, Error);
   friend class Class;
 };
 
 
 class LanguageError : public Error {
  public:
   RawString* message() const { return raw_ptr()->message_; }
   static intptr_t message_offset() {
     return OFFSET_OF(RawLanguageError, message_);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLanguageError));
   }
 
   static RawLanguageError* New(const String& message,
                                Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_message(const String& message) const;
   static RawLanguageError* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(LanguageError, Error);
+  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_);
   }
@@ skipping 10 matching lines @@
   static RawUnhandledException* New(const Instance& exception,
                                     const Instance& stacktrace,
                                     Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_exception(const Instance& exception) const;
   void set_stacktrace(const Instance& stacktrace) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(UnhandledException, Error);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(UnhandledException, Error);
   friend class Class;
 };
 
 
 class UnwindError : public Error {
  public:
   RawString* message() const { return raw_ptr()->message_; }
   static intptr_t message_offset() {
     return OFFSET_OF(RawUnwindError, 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;
 
-  HEAP_OBJECT_IMPLEMENTATION(UnwindError, Error);
+  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:
   virtual bool Equals(const Instance& other) const;
   virtual RawInstance* Canonicalize() const;
@@ skipping 478 matching lines @@
   static RawMint* New(int64_t value, Heap::Space space = Heap::kNew);
   static RawMint* NewCanonical(int64_t value);
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawMint));
   }
 
  private:
   void set_value(int64_t value) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Mint, Integer);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Mint, Integer);
   friend class Class;
 };
 
 
 class Bigint : public Integer {
  private:
   typedef uint32_t Chunk;
   typedef uint64_t DoubleChunk;
   static const int kChunkSize = sizeof(Chunk);
 
@@ skipping 60 matching lines @@
 
   Chunk* ChunkAddr(intptr_t index) const {
     ASSERT(0 <= index);
     ASSERT(index < Length());
     uword digits_start = reinterpret_cast<uword>(raw_ptr()) + sizeof(RawBigint);
     return &(reinterpret_cast<Chunk*>(digits_start)[index]);
   }
 
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
-  HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Bigint, Integer);
   friend class BigintOperations;
   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 {
@@ skipping 17 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawDouble));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawDouble, value_); }
 
  private:
   void set_value(double value) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Double, Number);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Double, Number);
   friend class Class;
 };
 
 
 // String may not be '\0' terminated.
 class String : public Instance {
  public:
   // We use 30 bits for the hash code so that we consistently use a
   // 32bit Smi representation for the hash code on all architectures.
   static const intptr_t kHashBits = 30;
@@ skipping 232 matching lines @@
   }
 
   template<typename HandleType, typename ElementType, typename CallbackType>
   static void ReadFromImpl(SnapshotReader* reader,
                            String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            CallbackType new_symbol,
                            Snapshot::Kind kind);
 
-  HEAP_OBJECT_IMPLEMENTATION(String, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 
   friend class Class;
   friend class Symbols;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
 };
 
 
@@ skipping 341 matching lines @@
   static RawBool* Get(bool value) {
     return value ? Bool::True().raw() : Bool::False().raw();
   }
 
  private:
   void set_value(bool value) const { raw_ptr()->value_ = value; }
 
   // New should only be called to initialize the two legal bool values.
   static RawBool* New(bool value);
 
-  HEAP_OBJECT_IMPLEMENTATION(Bool, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Bool, Instance);
   friend class Class;
   friend class Object;  // To initialize the true and false values.
 };
 
 
 class Array : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 83 matching lines @@
   friend class Class;
   friend class String;
 };
 
 
 class ImmutableArray : public Array {
  public:
   static RawImmutableArray* New(intptr_t len, Heap::Space space = Heap::kNew);
 
  private:
-  HEAP_OBJECT_IMPLEMENTATION(ImmutableArray, Array);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray, Array);
   friend class Class;
 };
 
 
 class GrowableObjectArray : public Instance {
  public:
   intptr_t Capacity() const {
     NoGCScope no_gc;
     ASSERT(!IsNull());
     return Smi::Value(DataArray()->length_);
@@ skipping 88 matching lines @@
     // Filter stores based on source and target.
     if (!value->IsHeapObject()) return;
     if (value->IsNewObject() && data()->IsOldObject()) {
       uword ptr = reinterpret_cast<uword>(addr);
       Isolate::Current()->store_buffer()->AddPointer(ptr);
     }
   }
 
   static const int kDefaultInitialCapacity = 4;
 
-  HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
 class ByteArray : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 98 matching lines @@
   static RawInt8Array* New(const int8_t* data,
                            intptr_t len,
                            Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Int8Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Int8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Uint8Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length();
   }
@@ skipping 31 matching lines @@
   static RawUint8Array* New(const uint8_t* data,
                             intptr_t len,
                             Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Uint8Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Uint8ClampedArray : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length();
   }
@@ skipping 32 matching lines @@
   static RawUint8ClampedArray* New(const uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Uint8ClampedArray, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint8ClampedArray, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Int16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawInt16Array* New(const int16_t* data,
                             intptr_t len,
                             Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Int16Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Int16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Uint16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawUint16Array* New(const uint16_t* data,
                              intptr_t len,
                              Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Uint16Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Int32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawInt32Array* New(const int32_t* data,
                             intptr_t len,
                             Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Int32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Int32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Uint32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawUint32Array* New(const uint32_t* data,
                              intptr_t len,
                              Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Uint32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Int64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawInt64Array* New(const int64_t* data,
                             intptr_t len,
                             Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Int64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Int64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Uint64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * sizeof(uint64_t);
   }
@@ skipping 31 matching lines @@
   static RawUint64Array* New(const uint64_t* data,
                              intptr_t len,
                              Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Uint64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Float32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawFloat32Array* New(const float* data,
                               intptr_t len,
                               Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Float32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Float32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class Float64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 31 matching lines @@
   static RawFloat64Array* New(const double* data,
                               intptr_t len,
                               Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(Float64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Float64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalInt8Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<int8_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalInt8Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint8Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 41 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<uint8_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalUint8Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
   friend class TokenStream;
 };
 
 
 class ExternalUint8ClampedArray : public ExternalUint8Array {
  public:
   static RawExternalUint8ClampedArray* New(uint8_t* data,
                                            intptr_t len,
                                            void* peer,
                                            Dart_PeerFinalizer callback,
                                            Heap::Space space = Heap::kNew);
 
  private:
-  HEAP_OBJECT_IMPLEMENTATION(ExternalUint8ClampedArray, ExternalUint8Array);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint8ClampedArray,
+                                   ExternalUint8Array);
   friend class Class;
 };
 
 
 class ExternalInt16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
@@ skipping 36 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<int16_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalInt16Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<uint16_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalUint16Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalInt32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<int32_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalInt32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<uint32_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalUint32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalInt64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<int64_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalInt64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<uint64_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalUint64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalFloat32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<float>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalFloat32Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalFloat32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalFloat64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
@@ skipping 37 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
         reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
     return data + byte_offset;
   }
 
   void SetExternalData(ExternalByteArrayData<double>* data) {
     raw_ptr()->external_data_ = data;
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalFloat64Array, ByteArray);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalFloat64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 // DartFunction represents the abstract Dart class 'Function'.
 class DartFunction : public Instance {
  private:
-  HEAP_OBJECT_IMPLEMENTATION(DartFunction, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(DartFunction, Instance);
   friend class Class;
   friend class Instance;
 };
 
 
 class Closure : public AllStatic {
  public:
   static RawFunction* function(const Instance& closure) {
     return *FunctionAddr(closure);
   }
@@ skipping 84 matching lines @@
                             const GrowableObjectArray& pc_offset_list,
                             Heap::Space space = Heap::kNew);
 
   const char* ToCStringInternal(bool verbose) const;
 
  private:
   void set_function_array(const Array& function_array) const;
   void set_code_array(const Array& code_array) const;
   void set_pc_offset_array(const Array& pc_offset_array) const;
 
-  HEAP_OBJECT_IMPLEMENTATION(Stacktrace, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(Stacktrace, Instance);
   friend class Class;
 };
 
 
 // Internal JavaScript regular expression object.
 class JSRegExp : 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.
@@ skipping 59 matching lines @@
  private:
   void set_type(RegExType type) const { raw_ptr()->type_ = type; }
   void set_flags(intptr_t value) const { raw_ptr()->flags_ = value; }
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->data_length_ = Smi::New(value);
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
 };
 
 
 class WeakProperty : public Instance {
  public:
   RawObject* key() const {
     return raw_ptr()->key_;
   }
 
@@ skipping 14 matching lines @@
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawWeakProperty));
   }
 
   static void Clear(RawWeakProperty* raw_weak) {
     raw_weak->ptr()->key_ = Object::null();
     raw_weak->ptr()->value_ = Object::null();
   }
 
  private:
-  HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
   friend class Class;
 };
 
 
 // Breaking cycles and loops.
 RawClass* Object::clazz() const {
   uword raw_value = reinterpret_cast<uword>(raw_);
   if ((raw_value & kSmiTagMask) == kSmiTag) {
     return Smi::Class();
   }
@@ skipping 110 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_