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 -1;

[Ivan Posva, 2013/11/02 00:25:55]

How about -kWordSize and then the scaling becomes automatic.

[siva, 2013/11/02 03:45:00]

Done.

+  }
+
   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 100 matching lines @@
   void set_instance_size(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_instance_size_in_words(value_in_bytes / kWordSize);
   }
   void set_instance_size_in_words(intptr_t value) const {
     ASSERT(Utils::IsAligned((value * kWordSize), kObjectAlignment));
     raw_ptr()->instance_size_in_words_ = value;
   }
 
   intptr_t next_field_offset() const {
+    if (raw_ptr()->next_field_offset_in_words_ == -1) {

[Ivan Posva, 2013/11/02 00:25:55]

I think we can remove this test and just return a negative value below.

[siva, 2013/11/02 03:45:00]

Done.

+      return -1;
+    }
     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);
+    if (value_in_bytes == -1) {

[Ivan Posva, 2013/11/02 00:25:55]

I would think this test can go too.

[siva, 2013/11/02 03:45:00]

Done.

+      set_next_field_offset_in_words(-1);
+    } else {
+      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 -1;
+  }
   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() {
+    // Indicates this class cannot be extended by dart code.
+    return -1;
+  }

[Ivan Posva, 2013/11/02 00:25:55]

Empty line here and other places.

[siva, 2013/11/02 03:45:00]

Done.

   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 -1;
+  }
+
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
+
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   // 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 -1;
+  }
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   // 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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
+
   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 -1;
+  }
+
   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() {
+    // Indicates this class cannot be extended by dart code.
+    return -1;
+  }

[Ivan Posva, 2013/11/02 00:25:55]

Doesn't this correspond to the Dart class Type, which can indeed be extended by
Dart code. The resulting object is not very useful, but there is no provision in
the spec to prevent extension of this.

[siva, 2013/11/02 03:45:00]

Done.

   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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);
 
@@ skipping 38 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 -1;
+  }
+
   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 -1;
+  }
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
+
   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 -1;
+  }
   // 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 -1;
+  }
+
   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 -1;
+  }
   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);
+  }
+
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
   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 -1;
+  }
+
   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 -1;
+  }
 
   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 -1;
+  }
+
   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 -1;
+  }
+
   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);
+  }
+
   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 -1;
+  }
+
   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_