Compute next field offset correctly.

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 VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 510 matching lines @@
     if (value->IsNewObject() && raw()->IsOldObject() &&
         !raw()->IsRemembered()) {
       raw()->SetRememberedBit();
       Isolate::Current()->store_buffer()->AddObject(raw());
     }
   }
 
   RawObject* raw_;  // The raw object reference.
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static void InitializeObject(uword address, intptr_t id, intptr_t size);
 
   static void RegisterClass(const Class& cls,
                             const String& name,
                             const Library& lib);
   static void RegisterPrivateClass(const Class& cls,
                                    const String& name,
                                    const Library& lib);
 
   /* Initialize the handle based on the raw_ptr in the presence of null. */
@@ skipping 107 matching lines @@
   }
 
   intptr_t next_field_offset() const {
     return raw_ptr()->next_field_offset_in_words_ * kWordSize;
   }
   void set_next_field_offset(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_next_field_offset_in_words(value_in_bytes / kWordSize);
   }
   void set_next_field_offset_in_words(intptr_t value) const {
-    ASSERT((Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
+    ASSERT((value == -1) ||
+           (Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             (value == raw_ptr()->instance_size_in_words_)) ||
            (!Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             ((value + 1) == raw_ptr()->instance_size_in_words_)));
     raw_ptr()->next_field_offset_in_words_ = value;
   }
 
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
     raw_ptr()->handle_vtable_ = value;
   }
@@ skipping 407 matching lines @@
   void set_constants(const Array& value) const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   RawArray* invocation_dispatcher_cache() const;
   void set_invocation_dispatcher_cache(const Array& cache) const;
   RawFunction* CreateInvocationDispatcher(const String& target_name,
                                           const Array& args_desc,
                                           RawFunction::Kind kind) const;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   void CalculateFieldOffsets() const;
 
   // Initial value for the cached number of type arguments.
   static const intptr_t kUnknownNumTypeArguments = -1;
 
   int16_t num_type_arguments() const {
     return raw_ptr()->num_type_arguments_;
   }
   void set_num_type_arguments(intptr_t value) const;
 
@@ skipping 41 matching lines @@
     return raw_ptr()->library_prefix_;
   }
   RawString* ident() const { return raw_ptr()->ident_; }
   intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
+
   static RawUnresolvedClass* New(const LibraryPrefix& library_prefix,
                                  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 intptr_t NextFieldOffset() {

[Ivan Posva, 2013/11/03 16:08:51]

We should maybe roll this into FINAL_HEAP_OBJECT_IMPLEMENTATION as it avoids
repeating it everywhere unnecessarily.

[siva, 2013/11/04 16:05:01]

Rolled it into FINAL_HEAP_OBJECT_IMPLEMENTATION and this means
class Type and class WeakProperty also have negative next_field_offset which
means they cannot be extended.

On 2013/11/03 16:08:51, Ivan Posva wrote:

+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawUnresolvedClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and
 // InstantiatedTypeArguments.
@@ skipping 149 matching lines @@
     return RoundedAllocationSize(
         sizeof(RawTypeArguments) + (len * kBytesPerElement));
   }
 
   static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld);
 
  private:
   RawAbstractType** TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
   friend class Class;
 };
 
 
 // An instance of InstantiatedTypeArguments is never encountered at compile
 // time, but only at run time, when type parameters can be matched to actual
 // types.
 // An instance of InstantiatedTypeArguments consists of a pair of
 // AbstractTypeArguments objects. The first type argument vector is
@@ skipping 42 matching lines @@
 
   static RawInstantiatedTypeArguments* New(
       const AbstractTypeArguments& uninstantiated_type_arguments,
       const AbstractTypeArguments& instantiator_type_arguments);
 
  private:
   void set_uninstantiated_type_arguments(
       const AbstractTypeArguments& value) const;
   void set_instantiator_type_arguments(
       const AbstractTypeArguments& value) const;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawInstantiatedTypeArguments* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments,
                                    AbstractTypeArguments);
   friend class Class;
 };
 
 
 class PatchClass : public Object {
  public:
   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
   RawClass* source_class() const { return raw_ptr()->source_class_; }
   RawScript* Script() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
 
   static RawPatchClass* New(const Class& patched_class,
                             const Class& source_class);
 
  private:
   void set_patched_class(const Class& value) const;
   void set_source_class(const Class& value) const;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawPatchClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
   friend class Class;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
@@ skipping 428 matching lines @@
   // Returns true if this function represents a local function.
   bool IsLocalFunction() const {
     return parent_function() != Function::null();
   }
 
   // Returns true if this function represents a signature function without code.
   bool IsSignatureFunction() const {
     return kind() == RawFunction::kSignatureFunction;
   }
 
-
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunction));
   }
 
   static RawFunction* New(const String& name,
                           RawFunction::Kind kind,
                           bool is_static,
                           bool is_const,
                           bool is_abstract,
                           bool is_external,
@@ skipping 69 matching lines @@
   void set_is_external(bool value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
   RawFunction* implicit_closure_function() const;
   void set_implicit_closure_function(const Function& value) const;
   RawInstance* implicit_static_closure() const;
   void set_implicit_static_closure(const Instance& closure) const;
   void set_num_optional_parameters(intptr_t value) const;  // Encoded value.
   void set_kind_tag(intptr_t value) const;
   void set_data(const Object& value) const;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawFunction* New();
 
   void BuildSignatureParameters(bool instantiate,
                                 NameVisibility name_visibility,
                                 const AbstractTypeArguments& instantiator,
                                 const GrowableObjectArray& pieces) const;
   RawString* BuildSignature(bool instantiate,
                             NameVisibility name_visibility,
                             const AbstractTypeArguments& instantiator) const;
 
@@ skipping 41 matching lines @@
   RawInstance* implicit_static_closure() const {
     return raw_ptr()->closure_;
   }
   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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawClosureData* New();
 
   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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawRedirectionData* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(RedirectionData, Object);
   friend class Class;
   friend class Function;
   friend class HeapProfiler;
 };
 
 
 class Field : public Object {
@@ skipping 157 matching lines @@
   }
   void set_owner(const Object& value) const {
     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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawField* New();
 
   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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LiteralToken, Object);
   friend class Class;
 };
 
 
 class TokenStream : public Object {
  public:
   RawArray* TokenObjects() const;
   void SetTokenObjects(const Array& value) const;
 
@@ skipping 63 matching lines @@
     Object& obj_;
     intptr_t cur_token_pos_;
     Token::Kind cur_token_kind_;
     intptr_t cur_token_obj_index_;
     Iterator::StreamType stream_type_;
   };
 
  private:
   void SetPrivateKey(const String& value) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawTokenStream* New();
   static void DataFinalizer(Dart_WeakPersistentHandle handle, void *peer);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
 
 class Script : public Object {
  public:
@@ skipping 37 matching lines @@
 
   static RawScript* New(const String& url,
                         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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawScript* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Script, Object);
   friend class Class;
 };
 
 
 class DictionaryIterator : public ValueObject {
  public:
   explicit DictionaryIterator(const Library& library);
@@ skipping 194 matching lines @@
 
 
   // 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);
 
  private:
   static const int kInitialImportsCapacity = 4;
   static const int kImportsCapacityIncrement = 8;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawLibrary* New();
 
   void set_num_imports(intptr_t value) const {
     raw_ptr()->num_imports_ = value;
   }
   RawArray* imports() const { return raw_ptr()->imports_; }
   RawArray* exports() const { return raw_ptr()->exports_; }
   bool HasExports() const;
   RawArray* loaded_scripts() const { return raw_ptr()->loaded_scripts_; }
   RawGrowableObjectArray* metadata() const { return raw_ptr()->metadata_; }
@@ skipping 42 matching lines @@
 
   static RawLibraryPrefix* New(const String& name, const Namespace& import);
 
  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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawLibraryPrefix* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Object);
   friend class Class;
 };
 
 
 // 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_; }
 
   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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawNamespace* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
   friend class Class;
 };
 
 
 class Instructions : public Object {
  public:
   intptr_t size() const { return raw_ptr()->size_; }  // Excludes HeaderSize().
@@ skipping 42 matching lines @@
   void set_size(intptr_t size) const {
     raw_ptr()->size_ = size;
   }
   void set_code(RawCode* code) const {
     raw_ptr()->code_ = code;
   }
   void set_object_pool(RawArray* object_pool) const {
     StorePointer(&raw_ptr()->object_pool_, object_pool);
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   // 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);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
   friend class Class;
   friend class Code;
 };
@@ skipping 22 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:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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.
@@ skipping 81 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));
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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;
 
@@ skipping 33 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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
   friend class BitmapBuilder;
   friend class Class;
 };
 
 
 class ExceptionHandlers : public Object {
  public:
   intptr_t Length() const;
 
@@ skipping 30 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;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
   friend class Class;
 };
 
 
 // Holds deopt information at one deoptimization point. The information consists
 // of two parts:
 //  - first a prefix consiting of kMaterializeObject instructions describing
 //    objects which had their allocation removed as part of AllocationSinking
 //    pass and have to be materialized;
@@ skipping 65 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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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 226 matching lines @@
     ASSERT(index < pointer_offsets_length());
     // TODO(iposva): Unit test is missing for this functionality.
     return &raw_ptr()->data_[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
   intptr_t BinarySearchInSCallTable(uword pc) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   // 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);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Code, Object);
   friend class Class;
 };
 
@@ skipping 47 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;
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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
@@ skipping 52 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);
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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 {
@@ skipping 137 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 Array& data) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
   friend class Class;
 };
 
 
 class MegamorphicCache : public Object {
  public:
   static const int kInitialCapacity = 16;
   static const double kLoadFactor;
 
@@ skipping 34 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);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache, Object);
 };
 
 
 class SubtypeTestCache : public Object {
  public:
   enum Entries {
     kInstanceClassId = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
@@ skipping 24 matching lines @@
 
  private:
   RawArray* cache() const {
     return raw_ptr()->cache_;
   }
 
   void set_cache(const Array& value) const;
 
   intptr_t TestEntryLength() const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache, Object);
   friend class Class;
 };
 
 
 class Error : public Object {
  public:
   virtual const char* ToErrorCString() const;
 
  private:
@@ skipping 12 matching lines @@
     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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawApiError* New();
 
   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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawLanguageError* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LanguageError, Error);
   friend class Class;
 };
 
 
 class UnhandledException : public Error {
  public:
   RawInstance* exception() const { return raw_ptr()->exception_; }
@@ skipping 13 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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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;
@@ skipping 66 matching lines @@
     return FieldAddrAtOffset(field.Offset());
   }
   RawObject** NativeFieldsAddr() const {
     return FieldAddrAtOffset(sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     StorePointer(FieldAddrAtOffset(offset), value.raw());
   }
   bool IsValidFieldOffset(int offset) const;
 
+  static intptr_t NextFieldOffset() {
+    return sizeof(RawInstance);
+  }
+
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class Class;
   friend class Closure;
+  friend class SnapshotWriter;
+  friend class StubCode;
   friend class TypedDataView;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Instance {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
@@ skipping 219 matching lines @@
 
   static RawType* New(const Object& clazz,
                       const AbstractTypeArguments& arguments,
                       intptr_t token_pos,
                       Heap::Space space = Heap::kOld);
 
  private:
   void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
 
+  static intptr_t NextFieldOffset() {
+    return sizeof(RawType);
+  }
+
   static RawType* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Type, 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.
@@ skipping 49 matching lines @@
                                intptr_t index,
                                const String& name,
                                const AbstractType& bound,
                                intptr_t token_pos);
 
  private:
   void set_parameterized_class(const Class& value) const;
   void set_name(const String& value) const;
   void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
+
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // 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
@@ skipping 56 matching lines @@
  private:
   void set_type(const AbstractType& value) const;
   void set_bound(const AbstractType& value) const;
   void set_type_parameter(const TypeParameter& value) const;
 
   bool is_being_checked() const {
     return raw_ptr()->is_being_checked_;
   }
   void set_is_being_checked(bool value) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawBoundedType* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(BoundedType, AbstractType);
   friend class Class;
 };
 
 
 // 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
@@ skipping 31 matching lines @@
 
   static RawMixinAppType* New(const AbstractType& super_type,
                               const Array& mixin_types);
 
  private:
   void set_super_type(const AbstractType& value) const;
 
   RawArray* mixin_types() const { return raw_ptr()->mixin_types_; }
   void set_mixin_types(const Array& value) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawMixinAppType* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MixinAppType, AbstractType);
   friend class Class;
 };
 
 
 class Number : public Instance {
  public:
   // TODO(iposva): Fill in a useful Number interface.
@@ skipping 106 matching lines @@
   void operator=(RawSmi* value) {
     raw_ = value;
     CHECK_HANDLE();
   }
   void operator^=(RawObject* value) {
     raw_ = value;
     CHECK_HANDLE();
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static intptr_t ValueFromRaw(uword raw_value) {
     intptr_t value = raw_value;
     ASSERT((value & kSmiTagMask) == kSmiTag);
     return (value >> kSmiTagShift);
   }
+
   static cpp_vtable handle_vtable_;
 
   Smi() : Integer() {}
   BASE_OBJECT_IMPLEMENTATION(Smi, Integer);
 
   friend class Api;  // For ValueFromRaw
   friend class Class;
   friend class Object;
 };
 
@@ skipping 33 matching lines @@
   // Only Integer::NewXXX is allowed to call Mint::NewXXX directly.
   friend class Integer;
 
   static RawMint* New(int64_t value, Heap::Space space = Heap::kNew);
 
   static RawMint* NewCanonical(int64_t value);
 
  private:
   void set_value(int64_t value) const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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 63 matching lines @@
     raw_ptr()->signed_length_ = -raw_ptr()->signed_length_;
   }
 
   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 intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawBigint* Allocate(intptr_t length, Heap::Space space = Heap::kNew);
 
   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.
@@ skipping 20 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;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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.
@@ skipping 362 matching lines @@
     ASSERT(str.IsOneByteString());
     NoGCScope no_gc;
     return &raw_ptr(str)->data_[index];
   }
 
   static RawOneByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class ExternalOneByteString;
   friend class SnapshotReader;
 };
 
 
 class TwoByteString : public AllStatic {
  public:
   static int32_t CharAt(const String& str, intptr_t index) {
@@ skipping 72 matching lines @@
     ASSERT(str.IsTwoByteString());
     NoGCScope no_gc;
     return &raw_ptr(str)->data_[index];
   }
 
   static RawTwoByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalOneByteString : public AllStatic {
  public:
   static int32_t CharAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
@@ skipping 48 matching lines @@
     raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_WeakPersistentHandle handle, void* peer);
 
   static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalTwoByteString : public AllStatic {
  public:
   static int32_t CharAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
@@ skipping 46 matching lines @@
     raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_WeakPersistentHandle handle, void* peer);
 
   static RawExternalTwoByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
   bool value() const {
@@ skipping 12 matching lines @@
     return Object::bool_false();
   }
 
   static const Bool& Get(bool value) {
     return value ? Bool::True() : Bool::False();
   }
 
  private:
   void set_value(bool value) const { raw_ptr()->value_ = value; }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   // 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 {
@@ skipping 89 matching lines @@
     ASSERT((index >= 0) && (index < Length()));
     return &raw_ptr()->data()[index];
   }
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->length_ = Smi::New(value);
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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);
 
   static const ClassId kClassId = kImmutableArrayCid;
 
   static intptr_t InstanceSize() {
     return Array::InstanceSize();
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return Array::InstanceSize(len);
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawImmutableArray* raw(const Array& array) {
     return reinterpret_cast<RawImmutableArray*>(array.raw());
   }
 
   friend class Class;
 };
 
 
 class GrowableObjectArray : public Instance {
  public:
@@ skipping 96 matching lines @@
     *addr = value;
     // Filter stores based on source and target.
     if (!value->IsHeapObject()) return;
     if (value->IsNewObject() && data()->IsOldObject() &&
         !data()->IsRemembered()) {
       data()->SetRememberedBit();
       Isolate::Current()->store_buffer()->AddObject(data());
     }
   }
 
+  static intptr_t NextFieldOffset() {
+    return sizeof(RawGrowableObjectArray);

[Ivan Posva, 2013/11/03 16:08:51]

Are you sure we need to be able to extend the VM's implementation of growable
lists?

[siva, 2013/11/04 16:05:01]

Removed this.

On 2013/11/03 16:08:51, Ivan Posva wrote:

+  }
+
   static const int kDefaultInitialCapacity = 4;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
 class Float32x4 : public Instance {
  public:
@@ skipping 17 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFloat32x4));
   }
 
   static intptr_t value_offset() {
     return OFFSET_OF(RawFloat32x4, value_);
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float32x4, Instance);
   friend class Class;
 };
 
 
 class Uint32x4 : public Instance {
  public:
   static RawUint32x4* New(uint32_t value0, uint32_t value1, uint32_t value2,
                           uint32_t value3, Heap::Space space = Heap::kNew);
   static RawUint32x4* New(simd128_value_t value,
@@ skipping 14 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUint32x4));
   }
 
   static intptr_t value_offset() {
     return OFFSET_OF(RawUint32x4, value_);
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint32x4, Instance);
   friend class Class;
 };
 
 
 class TypedData : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 107 matching lines @@
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsTypedDataClassId(cid);
   }
 
  protected:
   void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static const intptr_t element_size[];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypedData, Instance);
   friend class Class;
   friend class ExternalTypedData;
   friend class TypedDataView;
 };
 
 
 class ExternalTypedData : public Instance {
@@ skipping 99 matching lines @@
 
   void SetData(uint8_t* data) const {
     raw_ptr()->data_ = data;
   }
 
   void SetPeer(void* peer) const {
     raw_ptr()->peer_ = peer;
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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();
@@ skipping 18 matching lines @@
 
   static bool IsExternalTypedDataView(const Instance& view_obj) {
     const Instance& data = Instance::Handle(Data(view_obj));
     intptr_t cid = data.raw()->GetClassId();
     ASSERT(RawObject::IsTypedDataClassId(cid) ||
            RawObject::IsExternalTypedDataClassId(cid));
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
   static intptr_t NumberOfFields() {
-    return (kLengthOffset - kTypeArguments);
+    return kLengthOffset;
   }
 
   static intptr_t data_offset() {
     return kWordSize * kDataOffset;
   }
 
   static intptr_t offset_in_bytes_offset() {
     return kWordSize * kOffsetInBytesOffset;
   }
 
   static intptr_t length_offset() {
     return kWordSize * kLengthOffset;
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataViewClassId(class_id));
     return (class_id == kByteDataViewCid) ?
         TypedData::element_size[kTypedDataInt8ArrayCid] :
         TypedData::element_size[class_id - kTypedDataInt8ArrayViewCid];
   }
 
  private:
   enum {
-    kTypeArguments = 1,
-    kDataOffset = 2,
-    kOffsetInBytesOffset = 3,
-    kLengthOffset = 4,
+    kDataOffset = 1,
+    kOffsetInBytesOffset = 2,
+    kLengthOffset = 3,
   };
 };
 
 
 class Closure : public AllStatic {
  public:
   static RawFunction* function(const Instance& closure) {
     return *FunctionAddr(closure);
   }
   static intptr_t function_offset() {
@@ skipping 52 matching lines @@
         reinterpret_cast<intptr_t>(obj.raw_ptr()) + context_offset());
   }
   static void set_function(const Instance& closure,
                            const Function& value) {
     closure.StorePointer(FunctionAddr(closure), value.raw());
   }
   static void set_context(const Instance& closure,
                           const Context& value) {
     closure.StorePointer(ContextAddr(closure), value.raw());
   }
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
 
   friend class Class;
 };
 
 
 // Internal stacktrace object used in exceptions for printing stack traces.
 class Stacktrace : public Instance {
  public:
   static const int kPreallocatedStackdepth = 10;
 
@@ skipping 22 matching lines @@
   RawString* FullStacktrace() const;
   const char* ToCStringInternal(intptr_t* frame_index) const;
 
  private:
   void set_code_array(const Array& code_array) const;
   void set_pc_offset_array(const Array& pc_offset_array) const;
   void set_catch_code_array(const Array& code_array) const;
   void set_catch_pc_offset_array(const Array& pc_offset_array) const;
   bool expand_inlined() const;
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   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.
@@ skipping 60 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);
   }
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
 };
 
 
 class WeakProperty : public Instance {
  public:
   RawObject* key() const {
     return raw_ptr()->key_;
   }
@@ skipping 15 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:
+  static intptr_t NextFieldOffset() {
+    return sizeof(RawWeakProperty);

[Ivan Posva, 2013/11/03 16:08:51]

ditto. Internal VM implementation class, should this really be extensible by
Dart user code?

[siva, 2013/11/04 16:05:01]

Rolled this into FINAL_HEAL_OBJECT_IMPLEMENTATION so this would also not be
extensible.

On 2013/11/03 16:08:51, Ivan Posva wrote:

+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
   friend class Class;
 };
 
 
 class MirrorReference : public Instance {
  public:
   RawObject* referent() const {
     return raw_ptr()->referent_;
   }
@@ skipping 15 matching lines @@
   RawTypeParameter* GetTypeParameterReferent() const;
 
   static RawMirrorReference* New(const Object& referent,
                                  Heap::Space space = Heap::kNew);
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawMirrorReference));
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MirrorReference, 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 109 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_