- Rename class index to class id.

runtime/vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 214 matching lines @@
         AllocateUninitialized(cls_, Class::InstanceSize()));
     if (object_kind == kInstance) {
       Instance fake;
       obj->ptr()->handle_vtable_ = fake.vtable();
     } else {
       Closure fake;
       obj->ptr()->handle_vtable_ = fake.vtable();
     }
     cls_ = obj;
     cls_.set_instance_kind(object_kind);
-    cls_.set_index(kIllegalObjectKind);
+    cls_.set_id(kIllegalObjectKind);
     isolate()->class_table()->Register(cls_);
     return cls_.raw();
   }
   return Class::GetClass(object_kind);
 }
 
 
 RawMint* SnapshotReader::NewMint(int64_t value) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
@@ skipping 117 matching lines @@
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   raw_obj->ptr()->class_ = cls.raw();
   uword tags = 0;
-  intptr_t index = cls.index();
+  intptr_t index = cls.id();
   ASSERT(index != kIllegalObjectKind);
-  tags = RawObject::ClassTag::update(index, tags);
+  tags = RawObject::ClassIdTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header) {
   SerializedHeaderType header_type = SerializedHeaderTag::decode(header);
   intptr_t header_value = SerializedHeaderData::decode(header);
 
@@ skipping 134 matching lines @@
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
     WriteIndexedObject(ObjectStore::kFalseValue);
     return;
   }
 
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
-  if (RawObject::ClassTag::decode(GetObjectTags(rawobj)) == kCode) {
+  if (RawObject::ClassIdTag::decode(GetObjectTags(rawobj)) == kCode) {
     WriteIndexedObject(Object::kNullObject);
     return;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
   if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
     index = object_store()->GetTypeIndex(raw_type);
     if (index != ObjectStore::kInvalidIndex) {
       WriteIndexedObject(index);
@@ skipping 64 matching lines @@
   uword tags = raw->ptr()->tags_;
 
   // Check if object has already been serialized, in that
   // case just write the object id out.
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     WriteIndexedObject(id);
     return;
   }
 
-  RawClass* cls = class_table_->At(RawObject::ClassTag::decode(tags));
+  RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
 
   // Object is being serialized, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // an object id, instead of trying to serialize it again.
   intptr_t object_id = MarkObject(raw, cls);
 
   ObjectKind kind = cls->ptr()->instance_kind_;
   if (kind == Instance::kInstanceKind) {
     // Object is regular dart instance.
     // TODO(5411462): figure out what we need to do if an object with native
@@ skipping 71 matching lines @@
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObject(raw_obj);
   }
 }
 
 }  // namespace dart