- Implement first class types in the VM.

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/token.h"
 #include "vm/snapshot.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(TypeParameter)                                                           \
   V(AbstractTypeArguments)                                                     \
     V(TypeArguments)                                                           \
     V(InstantiatedTypeArguments)                                               \
   V(PatchClass)                                                                \
   V(Function)                                                                  \
   V(ClosureData)                                                               \
   V(RedirectionData)                                                           \
   V(Field)                                                                     \
   V(LiteralToken)                                                              \
   V(TokenStream)                                                               \
@@ skipping 11 matching lines @@
   V(Context)                                                                   \
   V(ContextScope)                                                              \
   V(ICData)                                                                    \
   V(SubtypeTestCache)                                                          \
   V(Error)                                                                     \
     V(ApiError)                                                                \
     V(LanguageError)                                                           \
     V(UnhandledException)                                                      \
     V(UnwindError)                                                             \
   V(Instance)                                                                  \
+    V(AbstractType)                                                            \
+      V(Type)                                                                  \
+      V(TypeParameter)                                                         \
     V(Number)                                                                  \
       V(Integer)                                                               \
         V(Smi)                                                                 \
         V(Mint)                                                                \
         V(Bigint)                                                              \
       V(Double)                                                                \
     V(String)                                                                  \
       V(OneByteString)                                                         \
       V(TwoByteString)                                                         \
       V(FourByteString)                                                        \
@@ skipping 387 matching lines @@
   RawLibraryPrefix* library_prefix_;  // Library prefix qualifier for the ident.
   RawString* ident_;  // Name of the unresolved identifier.
   RawClass* factory_signature_class_;  // Expected type parameters for factory.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->factory_signature_class_);
   }
   intptr_t token_pos_;
 };
 
 
-class RawAbstractType : public RawObject {
- protected:
-  enum TypeState {
-    kAllocated,  // Initial state.
-    kBeingFinalized,  // In the process of being finalized.
-    kFinalizedInstantiated,  // Instantiated type ready for use.
-    kFinalizedUninstantiated,  // Uninstantiated type ready for use.
-  };
-
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractType);
-
-  friend class ObjectStore;
-};
-
-
-class RawType : public RawAbstractType {
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(Type);
-
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->type_class_);
-  }
-  RawObject* type_class_;  // Either resolved class or unresolved class.
-  RawAbstractTypeArguments* arguments_;
-  RawError* malformed_error_;  // Error object if type is malformed.
-  RawObject** to() {
-      return reinterpret_cast<RawObject**>(&ptr()->malformed_error_);
-  }
-  intptr_t token_pos_;
-  int8_t type_state_;
-};
-
-
-class RawTypeParameter : public RawAbstractType {
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
-
-  RawObject** from() {
-      return reinterpret_cast<RawObject**>(&ptr()->parameterized_class_);
-  }
-  RawClass* parameterized_class_;
-  RawString* name_;
-  RawAbstractType* bound_;  // DynamicType if no explicit bound specified.
-  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->bound_); }
-  intptr_t index_;
-  intptr_t token_pos_;
-  int8_t type_state_;
-};
-
-
 class RawAbstractTypeArguments : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments);
 };
 
 
 class RawTypeArguments : public RawAbstractTypeArguments {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
@@ skipping 510 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->message_);
   }
 };
 
 
 class RawInstance : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instance);
 };
 
 
+class RawAbstractType : public RawInstance {
+ protected:
+  enum TypeState {
+    kAllocated,  // Initial state.
+    kBeingFinalized,  // In the process of being finalized.
+    kFinalizedInstantiated,  // Instantiated type ready for use.
+    kFinalizedUninstantiated,  // Uninstantiated type ready for use.
+  };
+
+ private:
+  RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractType);
+
+  friend class ObjectStore;
+};
+
+
+class RawType : public RawAbstractType {
+ private:
+  RAW_HEAP_OBJECT_IMPLEMENTATION(Type);
+
+  RawObject** from() {
+    return reinterpret_cast<RawObject**>(&ptr()->type_class_);
+  }
+  RawObject* type_class_;  // Either resolved class or unresolved class.
+  RawAbstractTypeArguments* arguments_;
+  RawError* malformed_error_;  // Error object if type is malformed.
+  RawObject** to() {
+    return reinterpret_cast<RawObject**>(&ptr()->malformed_error_);
+  }
+  intptr_t token_pos_;
+  int8_t type_state_;
+};
+
+
+class RawTypeParameter : public RawAbstractType {
+ private:
+  RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
+
+  RawObject** from() {
+    return reinterpret_cast<RawObject**>(&ptr()->parameterized_class_);
+  }
+  RawClass* parameterized_class_;
+  RawString* name_;
+  RawAbstractType* bound_;  // DynamicType if no explicit bound specified.
+  RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->bound_); }
+  intptr_t index_;
+  intptr_t token_pos_;
+  int8_t type_state_;
+};
+
+
 class RawNumber : public RawInstance {
   RAW_OBJECT_IMPLEMENTATION(Number);
 };
 
 
 class RawInteger : public RawNumber {
   RAW_OBJECT_IMPLEMENTATION(Integer);
 };
 
 
@@ skipping 570 matching lines @@
          kExternalUint64ArrayCid == kByteArrayCid + 18 &&
          kExternalFloat32ArrayCid == kByteArrayCid + 19 &&
          kExternalFloat64ArrayCid == kByteArrayCid + 20 &&
          kStacktraceCid == kByteArrayCid + 21);
   return (index >= kByteArrayCid && index <= kExternalFloat64ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_