- Rename class index to class id.

runtime/vm/raw_object.h

 // 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.
 
 #ifndef VM_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/token.h"
@@ skipping 96 matching lines @@
 #define DEFINE_OBJECT_KIND(clazz)                                              \
   k##clazz,
 CLASS_LIST(DEFINE_OBJECT_KIND)
 #undef DEFINE_OBJECT_KIND
   // The following entry does not describe a real object, but instead it
   // identifies free list elements in the heap.
   kFreeListElement,
   // The following entries do not describe a real object, but instead are used
   // to allocate class indexes for pre-allocated instance classes such as the
   // Null, Void, Dynamic and other similar classes.
-  kNullClassIndex,
-  kDynamicClassIndex,
-  kVoidClassIndex,
+  kNullClassId,
+  kDynamicClassId,
+  kVoidClassId,
   kNumPredefinedKinds = 100
 };
 
 enum ObjectAlignment {
   // Alignment offsets are used to determine object age.
   kNewObjectAlignmentOffset = kWordSize,
   kOldObjectAlignmentOffset = 0,
   // Object sizes are aligned to kObjectAlignment.
   kObjectAlignment = 2 * kWordSize,
   kObjectAlignmentLog2 = kWordSizeLog2 + 1,
@@ skipping 48 matching lines @@
     kFreeBit = 0,
     kMarkBit = 1,
     kCanonicalBit = 2,
     kFromSnapshotBit = 3,
     kReservedBit10K = 4,
     kReservedBit100K = 5,
     kReservedBit1M = 6,
     kReservedBit10M = 7,
     kSizeTagBit = 8,
     kSizeTagSize = 8,
-    kClassTagBit = kSizeTagBit + kSizeTagSize,
-    kClassTagSize = 16
+    kClassIdTagBit = kSizeTagBit + kSizeTagSize,
+    kClassIdTagSize = 16
   };
 
   // Encodes the object size in the tag in units of object alignment.
   class SizeTag {
    public:
     static const intptr_t kMaxSizeTag =
         ((1 << RawObject::kSizeTagSize) - 1) << kObjectAlignmentLog2;
 
     static uword encode(intptr_t size) {
       return SizeBits::encode(SizeToTagValue(size));
@@ skipping 13 matching lines @@
 
     static intptr_t SizeToTagValue(intptr_t size) {
       ASSERT(Utils::IsAligned(size, kObjectAlignment));
       return  (size > kMaxSizeTag) ? 0 : (size >> kObjectAlignmentLog2);
     }
     static intptr_t TagValueToSize(intptr_t value) {
       return value << kObjectAlignmentLog2;
     }
   };
 
-  class ClassTag : public BitField<intptr_t, kClassTagBit, kClassTagSize> {};
+  class ClassIdTag : public BitField<intptr_t,
+                                     kClassIdTagBit,
+                                     kClassIdTagSize> {};  // NOLINT
 
   bool IsHeapObject() const {
     uword value = reinterpret_cast<uword>(this);
     return (value & kSmiTagMask) == kHeapObjectTag;
   }
 
   bool IsNewObject() const {
     uword addr = reinterpret_cast<uword>(this);
     return (addr & kNewObjectAlignmentOffset) == kNewObjectAlignmentOffset;
   }
@@ skipping 61 matching lines @@
 
   static bool IsCreatedFromSnapshot(intptr_t value) {
     return CreatedFromSnapshotTag::decode(value);
   }
 
   static bool IsCanonical(intptr_t value) {
     return CanonicalObjectTag::decode(value);
   }
 
   // ObjectKind predicates.
-  static bool IsErrorClassIndex(intptr_t index);
-  static bool IsNumberClassIndex(intptr_t index);
-  static bool IsIntegerClassIndex(intptr_t index);
-  static bool IsStringClassIndex(intptr_t index);
-  static bool IsOneByteStringClassIndex(intptr_t index);
-  static bool IsTwoByteStringClassIndex(intptr_t index);
-  static bool IsExternalStringClassIndex(intptr_t index);
-  static bool IsBuiltinListClassIndex(intptr_t index);
-  static bool IsByteArrayClassIndex(intptr_t index);
+  static bool IsErrorClassId(intptr_t index);
+  static bool IsNumberClassId(intptr_t index);
+  static bool IsIntegerClassId(intptr_t index);
+  static bool IsStringClassId(intptr_t index);
+  static bool IsOneByteStringClassId(intptr_t index);
+  static bool IsTwoByteStringClassId(intptr_t index);
+  static bool IsExternalStringClassId(intptr_t index);
+  static bool IsBuiltinListClassId(intptr_t index);
+  static bool IsByteArrayClassId(intptr_t index);
 
  protected:
   RawClass* class_;
   uword tags_;  // Various object tags (bits).
 
  private:
   class FreeBit : public BitField<bool, kFreeBit, 1> {};
 
   class MarkBit : public BitField<bool, kMarkBit, 1> {};
 
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
 
   class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
 
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
-  intptr_t GetClassIndex() const {
+  intptr_t GetClassId() const {
     uword tags = ptr()->tags_;
-    return ClassTag::decode(tags);
+    return ClassIdTag::decode(tags);
   }
 
   friend class Api;
   friend class Array;
   friend class Heap;
   friend class MarkingVisitor;
   friend class Object;
   friend class RawInstructions;
   friend class SnapshotReader;
   friend class SnapshotWriter;
@@ skipping 31 matching lines @@
   RawArray* constants_;  // Canonicalized values of this class.
   RawArray* canonical_types_;  // Canonicalized types of this class.
   RawCode* allocation_stub_;  // Stub code for allocation of instances.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->allocation_stub_);
   }
 
   cpp_vtable handle_vtable_;
   intptr_t instance_size_;
   ObjectKind instance_kind_;
-  intptr_t index_;  // Index in the class table.
+  intptr_t id_;  // Class Id, also index in the class table.
   intptr_t type_arguments_instance_field_offset_;  // May be kNoTypeArguments.
   intptr_t next_field_offset_;  // Offset of then next instance field.
   intptr_t num_native_fields_;  // Number of native fields in class.
   intptr_t token_index_;
   int8_t class_state_;  // Of type ClassState.
   bool is_const_;
   bool is_interface_;
 
   friend class Object;
   friend class RawInstance;
@@ skipping 973 matching lines @@
 
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 // ObjectKind predicates.
 
-inline bool RawObject::IsErrorClassIndex(intptr_t index) {
+inline bool RawObject::IsErrorClassId(intptr_t index) {
   // Make sure this function is updated when new Error types are added.
   ASSERT(kApiError == kError + 1 &&
          kLanguageError == kError + 2 &&
          kUnhandledException == kError + 3 &&
          kUnwindError == kError + 4 &&
          kInstance == kError + 5);
   return (index >= kError && index < kInstance);
 }
 
-inline bool RawObject::IsNumberClassIndex(intptr_t index) {
+inline bool RawObject::IsNumberClassId(intptr_t index) {
   // Make sure this function is updated when new Number types are added.
   ASSERT(kInteger == kNumber + 1 &&
          kSmi == kNumber + 2 &&
          kMint == kNumber + 3 &&
          kBigint == kNumber + 4 &&
          kDouble == kNumber + 5 &&
          kString == kNumber + 6);
   return (index >= kNumber && index < kString);
 }
 
-inline bool RawObject::IsIntegerClassIndex(intptr_t index) {
+inline bool RawObject::IsIntegerClassId(intptr_t index) {
   // Make sure this function is updated when new Integer types are added.
   ASSERT(kSmi == kInteger + 1 &&
          kMint == kInteger + 2 &&
          kBigint == kInteger + 3 &&
          kDouble == kInteger + 4);
   return (index >= kInteger && index < kDouble);
 }
 
-inline bool RawObject::IsStringClassIndex(intptr_t index) {
+inline bool RawObject::IsStringClassId(intptr_t index) {
   // Make sure this function is updated when new String types are added.
   ASSERT(kOneByteString == kString + 1 &&
          kTwoByteString == kString + 2 &&
          kFourByteString == kString + 3 &&
          kExternalOneByteString == kString + 4 &&
          kExternalTwoByteString == kString + 5 &&
          kExternalFourByteString == kString + 6 &&
          kBool == kString + 7);
   return (index >= kString && index < kBool);
 }
 
-inline bool RawObject::IsOneByteStringClassIndex(intptr_t index) {
+inline bool RawObject::IsOneByteStringClassId(intptr_t index) {
   // Make sure this function is updated when new String types are added.
   ASSERT(kOneByteString == kString + 1 &&
          kTwoByteString == kString + 2 &&
          kFourByteString == kString + 3 &&
          kExternalOneByteString == kString + 4 &&
          kExternalTwoByteString == kString + 5 &&
          kExternalFourByteString == kString + 6 &&
          kBool == kString + 7);
   return (index == kOneByteString ||
           index == kExternalOneByteString);
 }
 
-inline bool RawObject::IsTwoByteStringClassIndex(intptr_t index) {
+inline bool RawObject::IsTwoByteStringClassId(intptr_t index) {
   // Make sure this function is updated when new String types are added.
   ASSERT(kOneByteString == kString + 1 &&
          kTwoByteString == kString + 2 &&
          kFourByteString == kString + 3 &&
          kExternalOneByteString == kString + 4 &&
          kExternalTwoByteString == kString + 5 &&
          kExternalFourByteString == kString + 6 &&
          kBool == kString + 7);
   return (index == kOneByteString ||
           index == kTwoByteString ||
           index == kExternalOneByteString ||
           index == kExternalTwoByteString);
 }
 
-inline bool RawObject::IsExternalStringClassIndex(intptr_t index) {
+inline bool RawObject::IsExternalStringClassId(intptr_t index) {
   // Make sure this function is updated when new String types are added.
   ASSERT(kOneByteString == kString + 1 &&
          kTwoByteString == kString + 2 &&
          kFourByteString == kString + 3 &&
          kExternalOneByteString == kString + 4 &&
          kExternalTwoByteString == kString + 5 &&
          kExternalFourByteString == kString + 6 &&
          kBool == kString + 7);
   return (index == kExternalOneByteString ||
           index == kExternalTwoByteString ||
           index == kExternalFourByteString);
 }
 
-inline bool RawObject::IsBuiltinListClassIndex(intptr_t index) {
+inline bool RawObject::IsBuiltinListClassId(intptr_t index) {
   // Make sure this function is updated when new builtin List types are added.
   ASSERT(kImmutableArray == kArray + 1 &&
          kGrowableObjectArray == kArray + 2 &&
          kByteArray == kArray + 3);
   return (index >= kArray && index < kByteArray);
 }
 
-inline bool RawObject::IsByteArrayClassIndex(intptr_t index) {
+inline bool RawObject::IsByteArrayClassId(intptr_t index) {
   // Make sure this function is updated when new ByteArray types are added.
   ASSERT(kInt8Array == kByteArray + 1 &&
          kUint8Array == kByteArray + 2 &&
          kInt16Array == kByteArray + 3 &&
          kUint16Array == kByteArray + 4 &&
          kInt32Array == kByteArray + 5 &&
          kUint32Array == kByteArray + 6 &&
          kInt64Array == kByteArray + 7 &&
          kUint64Array == kByteArray + 8 &&
          kFloat32Array == kByteArray + 9 &&
          kFloat64Array == kByteArray + 10 &&
          kExternalInt8Array == kByteArray + 11 &&
          kExternalUint8Array == kByteArray + 12 &&
          kExternalInt16Array == kByteArray + 13 &&
          kExternalUint16Array == kByteArray + 14 &&
          kExternalInt32Array == kByteArray + 15 &&
          kExternalUint32Array == kByteArray + 16 &&
          kExternalInt64Array == kByteArray + 17 &&
          kExternalUint64Array == kByteArray + 18 &&
          kExternalFloat32Array == kByteArray + 19 &&
          kExternalFloat64Array == kByteArray + 20 &&
          kClosure == kByteArray + 21);
   return (index >= kByteArray && index <= kClosure);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_