Fix snapshot reading of canonicalized types.

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 2957 matching lines @@
   return AbstractTypeArguments::AreIdentical(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()),
       false);  // Bounds are only checked at the top level.
 }
 
 
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
+    ASSERT(IsMalformed() || AbstractTypeArguments::Handle(arguments()).IsOld());
     return this->raw();
   }
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     return this->raw();
   }
   const intptr_t canonical_types_len = canonical_types.Length();
   // Linear search to see whether this type is already present in the
@@ skipping 10 matching lines @@
     if (!type.IsFinalized()) {
       ASSERT((index == 0) && cls.IsSignatureClass());
       index++;
       continue;
     }
     if (this->Equals(type)) {
       return type.raw();
     }
     index++;
   }
+  // Canonicalize the type arguments.
+  AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(arguments());
+  type_args = type_args.Canonicalize();
+  set_arguments(type_args);
   // The type needs to be added to the list. Grow the list if it is full.
   if (index == canonical_types_len) {
     const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
     const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
     const Array& new_canonical_types =
         Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
     cls.set_canonical_types(new_canonical_types);
     new_canonical_types.SetAt(index, *this);
   } else {
     canonical_types.SetAt(index, *this);
@@ skipping 620 matching lines @@
 
 void TypeArguments::SetLength(intptr_t value) const {
   ASSERT(!IsCanonical());
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   raw_ptr()->length_ = Smi::New(value);
 }
 
 
 RawAbstractTypeArguments* TypeArguments::Canonicalize() const {
-  if (IsNull() || IsCanonical() || !IsInstantiated()) {
+  if (IsNull() || IsCanonical()) {
+    ASSERT(IsOld());
     return this->raw();
   }
   ObjectStore* object_store = Isolate::Current()->object_store();
   // 'table' must be null terminated.
   Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   intptr_t index = 0;
   TypeArguments& result = TypeArguments::Handle();
   result ^= table.At(index);
   while (!result.IsNull()) {
@@ skipping 8473 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart