Fix snapshot reading of canonicalized types.

runtime/vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 177 matching lines @@
 RawType* Type::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type object.
   Type& type = Type::ZoneHandle(reader->isolate(), NEW_OBJECT(Type));
   reader->AddBackRef(object_id, &type, kIsDeserialized);
 
-  // Set the object tags.
-  type.set_tags(tags);
-
   // Set all non object fields.
   type.set_token_pos(reader->ReadIntptrValue());
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type.raw()->to() - type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     type.StorePointer((type.raw()->from() + i), reader->ReadObjectRef());
   }
 
   // If object needs to be a canonical object, Canonicalize it.
-  if ((kind != Snapshot::kFull) && type.IsCanonical()) {
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
     type ^= type.Canonicalize();
   }
+
+  // Set the object tags (This is done after 'Canonicalize', which
+  // does not canonicalize a type already marked as canonical).
+  type.set_tags(tags);
+
   return type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 98 matching lines @@
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^= reader->ReadObjectImpl();
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
+  // If object needs to be a canonical object, Canonicalize it.
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+    type_arguments ^= type_arguments.Canonicalize();
+  }
+
   // Set the object tags (This is done after setting the object fields
   // because 'SetTypeAt' has an assertion to check if the object is not
-  // already canonical).
+  // already canonical. Also, this is done after 'Canonicalize', which
+  // does not canonicalize a type already marked as canonical).
   type_arguments.set_tags(tags);
 
-  // If object needs to be a canonical object, Canonicalize it.
-  if ((kind != Snapshot::kFull) && type_arguments.IsCanonical()) {
-    type_arguments ^= type_arguments.Canonicalize();
-  }
   return type_arguments.raw();
 }
 
 
 void RawTypeArguments::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 1970 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart