Use null type argument vector instead of vector of Dynamic for a generic raw

runtime/vm/dart_api_message.cc

 // 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.
 
 #include "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 // TODO(sgjesse): When the external message format is done these
 // duplicate constants from snapshot.cc should be removed.
 enum {
   kInstanceId = ObjectStore::kMaxId,
   kMaxPredefinedObjectIds,
 };
 static const int kNumInitialReferences = 4;
 
 ApiMessageReader::ApiMessageReader(const uint8_t* buffer,
-                               intptr_t length,
-                               ReAlloc alloc)
+                                   intptr_t length,
+                                   ReAlloc alloc)
     : BaseReader(buffer, length),
       alloc_(alloc),
       backward_references_(kNumInitialReferences) {
   Init();
 }
 
 
 void ApiMessageReader::Init() {
   // Initialize marker objects used to handle Lists.
   // TODO(sjesse): Remove this when message serialization format is
@@ skipping 155 matching lines @@
       Dart_CObject* length = ReadObject();
       ASSERT(length->type == Dart_CObject::kInt32);
       for (int i = 0; i < length->value.as_int32; i++) {
         Dart_CObject* type = ReadObject();
         if (type != &dynamic_type_marker) {
           return NULL;
         }
       }
       return value;
     }
+    case Object::kTypeParameterClass: {
+      // TODO(sgjesse): Fix this workaround ignoring the type parameter.
+      Dart_CObject* value = &dynamic_type_marker;
+      AddBackwardReference(object_id, value);
+      intptr_t index = ReadIntptrValue();
+      USE(index);
+      intptr_t token_index = ReadIntptrValue();
+      USE(token_index);
+      int8_t type_state = Read<int8_t>();
+      USE(type_state);
+      Dart_CObject* parameterized_class = ReadObject();
+      // The type parameter is finalized, therefore parameterized_class is null.
+      ASSERT(parameterized_class->type == Dart_CObject::kNull);
+      Dart_CObject* name = ReadObject();
+      ASSERT(name->type == Dart_CObject::kString);
+      return value;
+    }
     case ObjectStore::kArrayClass: {
       intptr_t len = ReadSmiValue();
       Dart_CObject* value = AllocateDartCObjectArray(len);
       AddBackwardReference(object_id, value);
       // Skip type arguments.
       // TODO(sjesse): Remove this when message serialization format is
       // updated (currently type_arguments is leaked).
       Dart_CObject* type_arguments = ReadObject();
       if (type_arguments != &type_arguments_marker &&
           type_arguments->type != Dart_CObject::kNull) {
@@ skipping 81 matching lines @@
   } else if (object_id == ObjectStore::kDynamicType ||
              object_id == ObjectStore::kDoubleInterface ||
              object_id == ObjectStore::kIntInterface ||
              object_id == ObjectStore::kBoolInterface ||
              object_id == ObjectStore::kStringInterface ||
              object_id == ObjectStore::kByteArrayInterface) {
     // Always return dynamic type (this is only a marker).
     return &dynamic_type_marker;
   } else {
     intptr_t index = object_id - kMaxPredefinedObjectIds;
-    ASSERT(index < backward_references_.length());
+    ASSERT((0 <= index) && (index < backward_references_.length()));
     ASSERT(backward_references_[index] != NULL);
     return backward_references_[index];
   }
   return NULL;
 }
 
 
 Dart_CObject* ApiMessageReader::ReadObjectImpl(intptr_t header) {
   SerializedHeaderType header_type = SerializedHeaderTag::decode(header);
   intptr_t header_value = SerializedHeaderData::decode(header);
@@ skipping 232 matching lines @@
 }
 
 
 void ApiMessageWriter::WriteCMessage(Dart_CObject* object) {
   WriteCObject(object);
   UnmarkAllCObjects(object);
   FinalizeBuffer();
 }
 
 }  // namespace dart