Fix for issue 23647 (https://github.com/dart-lang/sdk/issues/23647)

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/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 1687 matching lines @@
   // Check if the value could potentially fit in a Smi in our current
   // architecture, if so return the object as a Smi.
   if (Smi::IsValid(value)) {
     return Smi::New(static_cast<intptr_t>(value));
   }
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->zone(), Mint::null());
   if (kind == Snapshot::kFull) {
     mint = reader->NewMint(value);
+    // Set the object tags.
+    mint.set_tags(tags);
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
     // When reading a message snapshot we always have to canonicalize.
     if (RawObject::IsCanonical(tags) &&
         (RawObject::IsCreatedFromSnapshot(tags) ||
          (kind == Snapshot::kMessage))) {
       mint = Mint::NewCanonical(value);
+      ASSERT(mint.IsCanonical() &&
+             (kind == Snapshot::kMessage ||
+              RawObject::IsCreatedFromSnapshot(mint.raw()->ptr()->tags_)));
     } else {
       mint = Mint::New(value, HEAP_SPACE(kind));
+      // Set the object tags.
+      mint.set_tags(tags);
     }
   }
   reader->AddBackRef(object_id, &mint, kIsDeserialized);
-
-  // Set the object tags.
-  mint.set_tags(tags);
-
   return mint.raw();
 }
 
 
 void RawMint::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 29 matching lines @@
   }
 
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
   // canonicalized as they are already canonical.
   // When reading a message snapshot we always have to canonicalize the object.
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags) &&
-      (RawObject::IsCreatedFromSnapshot(tags) ||
-       (kind == Snapshot::kMessage))) {
+  if (kind == Snapshot::kFull) {
+    // Set the object tags.
+    obj.set_tags(tags);
+  } else if (RawObject::IsCanonical(tags) &&
+             (RawObject::IsCreatedFromSnapshot(tags) ||
+              (kind == Snapshot::kMessage))) {
     obj ^= obj.CheckAndCanonicalize(NULL);
     ASSERT(!obj.IsNull());
+    ASSERT(obj.IsCanonical() &&
+           (kind == Snapshot::kMessage ||
+            RawObject::IsCreatedFromSnapshot(obj.raw()->ptr()->tags_)));
+  } else {
+    // Set the object tags.
+    obj.set_tags(tags);
   }
-
-  // Set the object tags.
-  obj.set_tags(tags);
-
   return obj.raw();
 }
 
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 15 matching lines @@
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
   // Read the double value for the object.
   double value = reader->ReadDouble();
 
   // Create a Double object or get canonical one if it is a canonical constant.
   Double& dbl = Double::ZoneHandle(reader->zone(), Double::null());
   if (kind == Snapshot::kFull) {
     dbl = reader->NewDouble(value);
+    // Set the object tags.
+    dbl.set_tags(tags);
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
     if (RawObject::IsCanonical(tags) &&
         RawObject::IsCreatedFromSnapshot(tags)) {
       dbl = Double::NewCanonical(value);
+      ASSERT(dbl.IsCanonical() &&
+             (kind == Snapshot::kMessage ||
+              RawObject::IsCreatedFromSnapshot(dbl.raw()->ptr()->tags_)));
     } else {
       dbl = Double::New(value, HEAP_SPACE(kind));
+      // Set the object tags.
+      dbl.set_tags(tags);
     }
   }
   reader->AddBackRef(object_id, &dbl, kIsDeserialized);
-
-  // Set the object tags.
-  dbl.set_tags(tags);
-
   return dbl.raw();
 }
 
 
 void RawDouble::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 1104 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart