Properly set the element type of literal lists.

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2429 matching lines @@
   instantiated_type.set_is_finalized_instantiated();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
-  if (IsMalformed() || !other.IsType() || other.IsMalformed()) {
+  if (IsMalformed() || other.IsMalformed() ||
+      (!other.IsType() && !other.IsInstantiatedType())) {
     return false;
   }
-  Type& other_type = Type::Handle();
-  other_type ^= other.raw();
-  if (type_class() != other_type.type_class()) {
+  if (type_class() != other.type_class()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()));
 }
 
 
 bool Type::IsIdentical(const AbstractType& other) const {
   if (raw() == other.raw()) {
@@ skipping 314 matching lines @@
     const AbstractType& uninstantiated_type,
     const AbstractTypeArguments& instantiator_type_arguments) {
   const InstantiatedType& result =
       InstantiatedType::Handle(InstantiatedType::New());
   result.set_uninstantiated_type(uninstantiated_type);
   result.set_instantiator_type_arguments(instantiator_type_arguments);
   return result.raw();
 }
 
 
+bool InstantiatedType::Equals(const AbstractType& other) const {
+  ASSERT(IsFinalized() && other.IsFinalized());
+  if (raw() == other.raw()) {
+    return true;
+  }
+  if (IsMalformed() || other.IsMalformed() ||
+      (!other.IsType() && !other.IsInstantiatedType())) {
+    return false;
+  }
+  if (type_class() != other.type_class()) {
+    return false;
+  }
+  return AbstractTypeArguments::AreEqual(
+      AbstractTypeArguments::Handle(arguments()),
+      AbstractTypeArguments::Handle(other.arguments()));
+}
+
+
 const char* InstantiatedType::ToCString() const {
   return "InstantiatedType";
 }
 
 
 intptr_t AbstractTypeArguments::Length() const  {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
@@ skipping 5904 matching lines @@
   }
 }
 
 
 const char* Array::ToCString() const {
   return "Array";
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
-  intptr_t len = source.IsNull() ? 0 : source.Length();
+  const Array& result = Array::Handle(Array::New(new_length, space));
+  intptr_t len = 0;
+  if (!source.IsNull()) {
+    len = source.Length();
+    result.SetTypeArguments(
+        AbstractTypeArguments::Handle(source.GetTypeArguments()));
+  }
   ASSERT(new_length >= len);  // Cannot copy 'source' into new array.
   ASSERT(new_length != len);  // Unnecessary copying of array.
-  const Array& result = Array::Handle(Array::New(new_length, space));
   Object& obj = Object::Handle();
   for (int i = 0; i < len; i++) {
     obj = source.At(i);
     result.SetAt(i, obj);
   }
   return result.raw();
 }
 
 
 RawArray* Array::Empty() {
@@ skipping 96 matching lines @@
   contents.SetAt(index, value);
 }
 
 
 void GrowableObjectArray::Grow(intptr_t new_capacity, Heap::Space space) const {
   ASSERT(new_capacity > Capacity());
   const Array& contents = Array::Handle(data());
   const Array& new_contents =
       Array::Handle(Array::Grow(contents, new_capacity, space));
   StorePointer(&(raw_ptr()->data_), new_contents.raw());
+  ASSERT(AbstractTypeArguments::AreEqual(
+      AbstractTypeArguments::Handle(new_contents.GetTypeArguments()),
+      AbstractTypeArguments::Handle(raw_ptr()->type_arguments_)));
 }
 
 
 RawObject* GrowableObjectArray::RemoveLast() const {
   ASSERT(!IsNull());
   ASSERT(Length() > 0);
   intptr_t index = Length() - 1;
   const Array& contents = Array::Handle(data());
   const Object& obj = Object::Handle(contents.At(index));
   contents.SetAt(index, Object::Handle());
@@ skipping 524 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart