Make Type, TypeParameter, TypeArguments and InstantiatedTypeArguments final heap objects.

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 1058 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;
 
-  HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
+  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
 // uninstantiated, because it contains type expressions referring to at least
@@ skipping 34 matching lines @@
       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 RawInstantiatedTypeArguments* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, AbstractTypeArguments);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments,
+                                   AbstractTypeArguments);
   friend class Class;
 };
 
 
 class PatchClass : public Object {
  public:
   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
   RawScript* script() const { return raw_ptr()->script_; }
 
   static intptr_t InstanceSize() {
@@ skipping 2406 matching lines @@
                       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 RawType* New(Heap::Space space = Heap::kOld);
 
-  HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
+  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.
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
@@ skipping 39 matching lines @@
                                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 RawTypeParameter* New();
 
-  HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 class Number : public Instance {
  public:
   // TODO(iposva): Fill in a useful Number interface.
   virtual bool IsZero() const {
     // Number is an abstract class.
     UNREACHABLE();
@@ skipping 2689 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_