Unify class ids and snapshot object ids list so that we don't have disparate and sometimes confusin…

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 88 matching lines @@
   /* is not setup for type T, although some methods are supposed to work   */  \
   /* with null, for example Instance::Equals().                            */  \
   static const object& Cast(const Object& obj) {                               \
     ASSERT(obj.Is##object());                                                  \
     return reinterpret_cast<const object&>(obj);                               \
   }                                                                            \
   static Raw##object* null() {                                                 \
     return reinterpret_cast<Raw##object*>(Object::null());                     \
   }                                                                            \
   virtual const char* ToCString() const;                                       \
-  static const ObjectKind kInstanceKind = k##object;                           \
+  static const ClassId kClassId = k##object##Cid;                              \
  protected:  /* NOLINT */                                                      \
   object() : super() {}                                                        \
  private:  /* NOLINT */                                                        \
   /* Initialize the handle based on the raw_ptr in the presence of null. */    \
   static void initializeHandle(object* obj, RawObject* raw_ptr) {              \
     if (raw_ptr != Object::null()) {                                           \
       obj->SetRaw(raw_ptr);                                                    \
     } else {                                                                   \
       obj->raw_ = Object::null();                                              \
       object fake_object;                                                      \
@@ skipping 18 matching lines @@
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
-  // Index for Singleton internal VM classes,
-  // this index is used in snapshots to refer to these classes directly.
-  enum {
-    kNullObject = 0,
-    kSentinelObject,
-    kClassClass,
-    kNullClass,
-    kDynamicClass,
-    kVoidClass,
-    kUnresolvedClassClass,
-    kTypeClass,
-    kTypeParameterClass,
-    kTypeArgumentsClass,
-    kInstantiatedTypeArgumentsClass,
-    kFunctionClass,
-    kFieldClass,
-    kLiteralTokenClass,
-    kTokenStreamClass,
-    kScriptClass,
-    kLibraryClass,
-    kLibraryPrefixClass,
-    kCodeClass,
-    kInstructionsClass,
-    kPcDescriptorsClass,
-    kStackmapClass,
-    kLocalVarDescriptorsClass,
-    kExceptionHandlersClass,
-    kDeoptInfoClass,
-    kContextClass,
-    kContextScopeClass,
-    kICDataClass,
-    kSubtypeTestCacheClass,
-    kApiErrorClass,
-    kLanguageErrorClass,
-    kUnhandledExceptionClass,
-    kUnwindErrorClass,
-    kMaxId,
-    kInvalidIndex = -1,
-  };
-
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) { SetRaw(value); }
 
   void set_tags(intptr_t value) const {
     // TODO(asiva): Remove the capability of setting tags in general. The mask
     // here only allows for canonical and from_snapshot flags to be set.
     ASSERT(!IsNull());
     uword tags = raw()->ptr()->tags_ & ~0x0000000c;
@@ skipping 119 matching lines @@
   static RawClass* context_scope_class() { return context_scope_class_; }
   static RawClass* api_error_class() { return api_error_class_; }
   static RawClass* language_error_class() { return language_error_class_; }
   static RawClass* unhandled_exception_class() {
     return unhandled_exception_class_;
   }
   static RawClass* unwind_error_class() { return unwind_error_class_; }
   static RawClass* icdata_class() { return icdata_class_; }
   static RawClass* subtypetestcache_class() { return subtypetestcache_class_; }
 
-  static int GetSingletonClassIndex(const RawClass* raw_class);
-  static RawClass* GetSingletonClass(int index);
-  static const char* GetSingletonClassName(int index);
+  static const char* GetSingletonClassName(intptr_t class_id);
 
   static RawClass* CreateAndRegisterInterface(const char* cname,
                                               const Script& script,
                                               const Library& lib);
   static void RegisterClass(const Class& cls,
                             const char* cname,
                             const Script& script,
                             const Library& lib);
 
   static void RegisterPrivateClass(const Class& cls,
                                    const char* cname,
                                    const Script& script,
                                    const Library& lib);
 
   static RawError* Init(Isolate* isolate);
   static void InitFromSnapshot(Isolate* isolate);
   static void InitOnce();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawObject));
   }
 
-  static const ObjectKind kInstanceKind = kObject;
+  static const ClassId kClassId = kObjectCid;
 
   // Different kinds of type tests.
   enum TypeTestKind {
     kIsSubtypeOf = 0,
     kIsMoreSpecificThan
   };
 
   // Different kinds of name visibility.
   enum NameVisibility {
     kInternalName = 0,
@@ skipping 43 matching lines @@
 
  private:
   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_;
-  static cpp_vtable builtin_vtables_[kNumPredefinedKinds];
+  static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
@@ skipping 61 matching lines @@
            (!Utils::IsAligned(value, kObjectAlignment) &&
             (value + kWordSize == raw_ptr()->instance_size_)));
     raw_ptr()->next_field_offset_ = value;
   }
 
   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 id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     raw_ptr()->id_ = value;
   }
 
   RawString* Name() const;
 
   RawString* UserVisibleName() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
@@ skipping 104 matching lines @@
   // Check if this class represents the 'void' class.
   bool IsVoidClass() const { return raw() == Object::void_class(); }
 
   // Check if this class represents the 'Object' class.
   bool IsObjectClass() const;
 
   // Check if this class represents a signature class.
   bool IsSignatureClass() const {
     return signature_function() != Object::null();
   }
+  static bool IsSignatureClass(RawClass* cls) {
+    return cls->ptr()->signature_function_ != Object::null();
+  }
 
   // Check if this class represents a canonical signature class, i.e. not an
   // alias as defined in a typedef.
   bool IsCanonicalSignatureClass() const;
 
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractTypeArguments& type_arguments,
                    const Class& other,
                    const AbstractTypeArguments& other_type_arguments,
                    Error* malformed_error) const {
@@ skipping 114 matching lines @@
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
                                      const Script& script);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
-  static RawClass* GetClass(ObjectKind kind);
+  static RawClass* GetClass(intptr_t class_id, bool is_signature_class);
 
  private:
   void set_name(const String& value) const;
   void set_script(const Script& value) const;
   void set_token_pos(intptr_t value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
@@ skipping 4607 matching lines @@
   }
 
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   Heap* isolate_heap = isolate->heap();
   Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
   ASSERT(isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())) ||
          vm_isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())));
 #endif
   intptr_t cid = raw_->GetClassId();
-  if (cid < kNumPredefinedKinds) {
+  if (cid < kNumPredefinedCids) {
 #if defined(DEBUG)
     ASSERT(builtin_vtables_[cid] ==
            isolate->class_table()->At(cid)->ptr()->handle_vtable_);
 #endif
     set_vtable(builtin_vtables_[cid]);
   } else {
 #if !defined(DEBUG)
     Isolate* isolate = Isolate::Current();
 #endif
     RawClass* raw_class = isolate->class_table()->At(cid);
@@ skipping 59 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_