Implement eager instantiation and canonicalization of type arguments at run

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_NOR_STRING_NOR_ARRAY(V)                           \
   V(Class)                                                                     \
   V(UnresolvedClass)                                                           \
-  V(AbstractTypeArguments)                                                     \
-    V(TypeArguments)                                                           \
-    V(InstantiatedTypeArguments)                                               \
+  V(TypeArguments)                                                             \
   V(PatchClass)                                                                \
   V(Function)                                                                  \
   V(ClosureData)                                                               \
   V(RedirectionData)                                                           \
   V(Field)                                                                     \
   V(LiteralToken)                                                              \
   V(TokenStream)                                                               \
   V(Script)                                                                    \
   V(Library)                                                                   \
   V(LibraryPrefix)                                                             \
@@ skipping 498 matching lines @@
   }
   RawLibraryPrefix* library_prefix_;  // Library prefix qualifier for the ident.
   RawString* ident_;  // Name of the unresolved identifier.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->ident_);
   }
   intptr_t token_pos_;
 };
 
 
-class RawAbstractTypeArguments : public RawObject {
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments);
-};
-
-
-class RawTypeArguments : public RawAbstractTypeArguments {
+class RawTypeArguments : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
 
   RawObject** from() {
-    return reinterpret_cast<RawObject**>(&ptr()->length_);
+    return reinterpret_cast<RawObject**>(&ptr()->instantiations_);
   }
+  // The instantiations_ array remains empty for instantiated type arguments.
+  RawArray* instantiations_;  // Array of paired canonical vectors:
+                              // Even index: instantiator.
+                              // Odd index: instantiated (without bound error).
+  // Instantiations leading to bound errors do not get cached.
   RawSmi* length_;
 
   // Variable length data follows here.
   RawAbstractType* types_[0];
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types_[length - 1]);
   }
 
   friend class SnapshotReader;
 };
 
 
-class RawInstantiatedTypeArguments : public RawAbstractTypeArguments {
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments);
-
-  RawObject** from() {
-    return reinterpret_cast<RawObject**>(
-        &ptr()->uninstantiated_type_arguments_);
-  }
-  RawAbstractTypeArguments* uninstantiated_type_arguments_;
-  RawAbstractTypeArguments* instantiator_type_arguments_;
-  RawObject** to() {
-    return reinterpret_cast<RawObject**>(&ptr()->instantiator_type_arguments_);
-  }
-};
-
-
 class RawPatchClass : public RawObject {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(PatchClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->patched_class_);
   }
   RawClass* patched_class_;
   RawClass* source_class_;
   RawObject** to() {
@@ skipping 576 matching lines @@
 
 
 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_;
+  RawTypeArguments* arguments_;
   RawLanguageError* error_;  // Error object if type is malformed or malbounded.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->error_);
   }
   intptr_t token_pos_;
   int8_t type_state_;
 };
 
 
 class RawTypeRef : public RawAbstractType {
@@ skipping 190 matching lines @@
   bool value_;
 };
 
 
 class RawArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Array);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
-  RawAbstractTypeArguments* type_arguments_;
+  RawTypeArguments* 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 11 matching lines @@
   friend class SnapshotReader;
 };
 
 
 class RawGrowableObjectArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
-  RawAbstractTypeArguments* type_arguments_;
+  RawTypeArguments* type_arguments_;
   RawSmi* length_;
   RawArray* data_;
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->data_);
   }
 
   friend class SnapshotReader;
 };
 
 
@@ skipping 358 matching lines @@
   // Make sure this is updated when new TypedData types are added.
   ASSERT(kTypedDataInt8ArrayViewCid == kTypedDataInt8ArrayCid + 14);
   ASSERT(kExternalTypedDataInt8ArrayCid == kTypedDataInt8ArrayViewCid + 15);
   ASSERT(kNullCid == kExternalTypedDataInt8ArrayCid + 14);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_