- Rename class index to class id.

runtime/vm/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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 354 matching lines @@
     // Filter stores based on source and target.
     if (value->IsNewObject() && raw()->IsOldObject()) {
       uword ptr = reinterpret_cast<uword>(addr);
       Isolate::Current()->store_buffer()->AddPointer(ptr);
     }
   }
 
   RawObject* raw_;  // The raw object reference.
 
  private:
-  static void InitializeObject(uword address, intptr_t index, intptr_t size);
+  static void InitializeObject(uword address, intptr_t id, intptr_t size);
 
   cpp_vtable* vtable_address() const {
     uword vtable_addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
@@ skipping 71 matching lines @@
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
     raw_ptr()->handle_vtable_ = value;
   }
 
   ObjectKind instance_kind() const { return raw_ptr()->instance_kind_; }
   void set_instance_kind(ObjectKind value) const {
     raw_ptr()->instance_kind_ = value;
   }
 
-  intptr_t index() const { return raw_ptr()->index_; }
-  void set_index(intptr_t value) const {
-    raw_ptr()->index_ = value;
+  intptr_t id() const { return raw_ptr()->id_; }
+  void set_id(intptr_t value) const {
+    raw_ptr()->id_ = value;
   }
 
   RawString* Name() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
 
   intptr_t token_index() const { return raw_ptr()->token_index_; }
 
   // This class represents the signature class of a closure function if
   // signature_function() is not null.
@@ skipping 246 matching lines @@
   void CalculateFieldOffsets() const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   RawFunction* LookupAccessorFunction(const char* prefix,
                                       intptr_t prefix_length,
                                       const String& name) const;
 
   // Allocate an instance class which has a VM implementation.
-  template <class FakeInstance> static RawClass* New(intptr_t index);
+  template <class FakeInstance> static RawClass* New(intptr_t id);
   template <class FakeInstance> static RawClass* New(const String& name,
                                                      const Script& script,
                                                      intptr_t token_index);
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
   friend class Type;
 };
 
@@ skipping 117 matching lines @@
     if (!HasResolvedTypeClass()) {
       return false;
     }
     const Class& cls = Class::Handle(type_class());
     return !cls.IsNull() && cls.is_interface();
   }
 
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractType& other, Error* malformed_error) const;
 
-  static RawAbstractType* NewTypeParameter(const Class& parameterized_class,
-                                           intptr_t index,
-                                           const String& name,
-                                           intptr_t token_index);
-
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Object);
   friend class Class;
 };
 
 
 // A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 //
@@ skipping 3991 matching lines @@
 };
 
 
 // Breaking cycles and loops.
 RawClass* Object::clazz() const {
   uword raw_value = reinterpret_cast<uword>(raw_);
   if ((raw_value & kSmiTagMask) == kSmiTag) {
     return Smi::Class();
   }
   RawClass* result = raw_->ptr()->class_;
-  ASSERT(result->ptr()->index_ ==
-      RawObject::ClassTag::decode(raw_->ptr()->tags_));
+  ASSERT(result->ptr()->id_ ==
+      RawObject::ClassIdTag::decode(raw_->ptr()->tags_));
   ASSERT(Isolate::Current()->class_table()->At(
-      RawObject::ClassTag::decode(raw_->ptr()->tags_)) == result);
+      RawObject::ClassIdTag::decode(raw_->ptr()->tags_)) == result);
   return result;
 }
 
 
 void Object::SetRaw(RawObject* value) {
   // NOTE: The assignment "raw_ = value" should be the first statement in
   // this function. Also do not use 'value' in this function after the
   // assignment (use 'raw_' instead).
   raw_ = value;
   if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
@@ skipping 53 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_