Ongoing renaming of type classes:

runtime/vm/raw_object.h

 // Copyright (c) 2011, 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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/globals.h"
 #include "vm/snapshot.h"
 
 #include "include/dart_api.h"
 
 namespace dart {
 
 // Macrobatics to define the Object hierarchy of VM implementation classes.
 #define CLASS_LIST_NO_OBJECT(V)                                                \
   V(Class)                                                                     \
   V(UnresolvedClass)                                                           \
   V(AbstractType)                                                              \
-    V(Type)                                                       \
+    V(Type)                                                                    \
     V(TypeParameter)                                                           \
     V(InstantiatedType)                                                        \
-  V(TypeArguments)                                                             \
-    V(TypeArray)                                                               \
+  V(AbstractTypeArguments)                                                     \
+    V(TypeArguments)                                                           \
     V(InstantiatedTypeArguments)                                               \
   V(Function)                                                                  \
   V(Field)                                                                     \
   V(TokenStream)                                                               \
   V(Script)                                                                    \
   V(Library)                                                                   \
   V(LibraryPrefix)                                                             \
   V(Code)                                                                      \
   V(Instructions)                                                              \
   V(PcDescriptors)                                                             \
@@ skipping 184 matching lines @@
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawArray* functions_;
   RawArray* fields_;
   // TODO(srdjan): RawTypeArguments* interfaces_;  // Array of Type.
   RawArray* interfaces_;  // Array of AbstractType.
   RawScript* script_;
   RawLibrary* library_;
   RawArray* type_parameters_;  // Array of String.
-  RawTypeArray* type_parameter_extends_;  // DynamicType if no extends clause.
+  RawTypeArguments* type_parameter_extends_;  // DynamicType if no extends.
   RawType* super_type_;
   RawObject* factory_class_;  // UnresolvedClass (until finalization) or Class.
   RawFunction* signature_function_;  // Associated function for signature class.
   RawArray* functions_cache_;  // See class FunctionsCache.
   RawArray* constants_;  // Canonicalized values of this class.
   // TODO(srdjan): RawTypeArguments* canonical_types_;
   RawArray* canonical_types_;  // Canonicalized types of this class.
   RawCode* allocation_stub_;  // Stub code for allocation of instances.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->allocation_stub_);
@@ skipping 44 matching lines @@
     kBeingFinalized,  // In the process of being finalized.
     kFinalized,  // Type ready for use.
   };
 
   RAW_HEAP_OBJECT_IMPLEMENTATION(Type);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_class_);
   }
   RawObject* type_class_;  // Either resolved class or unresolved class.
-  RawTypeArguments* arguments_;
+  RawAbstractTypeArguments* arguments_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->arguments_); }
   int8_t type_state_;
 };
 
 
 class RawTypeParameter : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   RawString* name_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->name_); }
   intptr_t index_;
 };
 
 
 class RawInstantiatedType : public RawAbstractType {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(InstantiatedType);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->uninstantiated_type_);
   }
   RawAbstractType* uninstantiated_type_;
-  RawTypeArguments* instantiator_type_arguments_;
+  RawAbstractTypeArguments* instantiator_type_arguments_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->instantiator_type_arguments_);
   }
 };
 
 
-class RawTypeArguments : public RawObject {
-  RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
+class RawAbstractTypeArguments : public RawObject {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments);
 };
 
 
-class RawTypeArray : public RawTypeArguments {
+class RawTypeArguments : public RawAbstractTypeArguments {
  private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArray);
+  RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->length_);
   }
   RawSmi* length_;
 
   // Variable length data follows here.
   RawAbstractType* types_[0];
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types_[length - 1]);
   }
 };
 
 
-class RawInstantiatedTypeArguments : public RawTypeArguments {
+class RawInstantiatedTypeArguments : public RawAbstractTypeArguments {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(
         &ptr()->uninstantiated_type_arguments_);
   }
-  RawTypeArguments* uninstantiated_type_arguments_;
-  RawTypeArguments* instantiator_type_arguments_;
+  RawAbstractTypeArguments* uninstantiated_type_arguments_;
+  RawAbstractTypeArguments* instantiator_type_arguments_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->instantiator_type_arguments_);
   }
 };
 
 
 class RawFunction : public RawObject {
  public:
   enum Kind {
     kFunction,
@@ skipping 397 matching lines @@
   bool value_;
 };
 
 
 class RawArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Array);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
-  RawTypeArguments* type_arguments_;
+  RawAbstractTypeArguments* type_arguments_;
   RawSmi* length_;
   // Variable length data follows here.
   RawObject** data() {
     uword address_of_length = reinterpret_cast<uword>(&length_);
     return reinterpret_cast<RawObject**>(address_of_length + kWordSize);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
@@ skipping 15 matching lines @@
   uint8_t* data_;
 };
 
 
 class RawClosure : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
-  RawTypeArguments* type_arguments_;
+  RawAbstractTypeArguments* type_arguments_;
   RawFunction* function_;
   RawContext* context_;
   // TODO(iposva): Remove this temporary hack.
   RawInteger* smrck_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->smrck_); }
 };
 
 
 // VM type for capturing stacktraces when exceptions are thrown,
 // Currently we don't have any interface that this object is supposed
@@ skipping 31 matching lines @@
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_