Currently we use a generated number as the class id for object class, this change tries to pin it t…

vm/object.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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 618 matching lines @@
   name = Symbols::WeakProperty();
   RegisterClass(cls, name, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadCoreScript(false));
 
   // Allocate and initialize the Object class and type.  The Object
   // class and ByteArray subclasses are the only pre-allocated,
   // non-interface classes in the core library.
-  cls = Class::New<Instance>();
+  cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
   name = Symbols::Object();
   cls.set_name(name);
   cls.set_script(script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
@@ skipping 262 matching lines @@
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
 
   // Set up empty classes in the object store, these will get
   // initialized correctly when we read from the snapshot.
   // This is done to allow bootstrapping of reading classes from the snapshot.
+  cls = Class::New<Instance>(kInstanceCid);
+  object_store->set_object_class(cls);
+
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<Int8Array>();
@@ skipping 311 matching lines @@
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
-  result.set_id((FakeObject::kClassId != kInstanceCid &&
-                 FakeObject::kClassId != kClosureCid) ?
-                FakeObject::kClassId : kIllegalCid);
+  ASSERT((FakeObject::kClassId != kInstanceCid) &&
+         (FakeObject::kClassId != kClosureCid));
+  result.set_id(FakeObject::kClassId);
   result.raw_ptr()->state_bits_ = 0;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
@@ skipping 401 matching lines @@
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_id(index);
   result.raw_ptr()->state_bits_ = 0;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
+  result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
@@ skipping 72 matching lines @@
   // Cache the signature type as the first canonicalized type in result.
   const Type& signature_type = Type::Handle(result.SignatureType());
   ASSERT(!signature_type.IsFinalized());
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
-RawClass* Class::GetClass(intptr_t class_id, bool is_signature_class) {
-  if (class_id >= kIntegerCid && class_id <= kWeakPropertyCid) {
-    return Isolate::Current()->class_table()->At(class_id);
-  }
-  if (class_id >= kNumPredefinedCids) {
-    if (is_signature_class) {
-      return Class::New<Closure>();
-    }
-    return Class::New<Instance>();
-  }
-  OS::Print("Class::GetClass id unknown: %d\n", class_id);
-  UNREACHABLE();
-  return Class::null();
-}
-
-
 RawClass* Class::NewNativeWrapper(Library* library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library->LookupClass(name));
   if (cls.IsNull()) {
     const Array& empty_array = Array::Handle(Object::empty_array());
     cls = New<Instance>(name, Script::Handle(), Scanner::kDummyTokenIndex);
     cls.SetFields(empty_array);
     cls.SetFunctions(empty_array);
     // Set super class to Object.
@@ skipping 9354 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "WeakProperty";
 }
 
 }  // namespace dart