Ensure the classes void and dynamic have empty arrays for fields, functions, etc. Move their Types …

runtime/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/cpu.h"
@@ skipping 76 matching lines @@
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
 Smi* Object::smi_illegal_cid_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = NULL;
 LanguageError* Object::branch_offset_error_ = NULL;
 
 RawObject* Object::null_ = reinterpret_cast<RawObject*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawType* Object::dynamic_type_ = reinterpret_cast<RawType*>(RAW_NULL);
+RawType* Object::void_type_ = reinterpret_cast<RawType*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::redirection_data_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 325 matching lines @@
   }
 
   // Allocate and initialize optimizing compiler constants.
   {
     *unknown_constant_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     *non_constant_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
   }
 
-  cls = Class::New<Instance>(kDynamicCid);
-  cls.set_is_finalized();
-  cls.set_is_type_finalized();
-  cls.set_is_abstract();
-  dynamic_class_ = cls.raw();
-
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
-  cls = Class::New<Instance>(kVoidCid);
-  cls.set_is_finalized();
-  cls.set_is_type_finalized();
-  void_class_ = cls.raw();
-
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
   cls = Class::New<PatchClass>();
   patch_class_class_ = cls.raw();
 
   cls = Class::New<Function>();
@@ skipping 92 matching lines @@
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     Array::initializeHandle(
         empty_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 
+  cls = Class::New<Instance>(kDynamicCid);
+  cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  cls.set_is_abstract();
+  dynamic_class_ = cls.raw();
+
+  cls = Class::New<Instance>(kVoidCid);
+  cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  void_class_ = cls.raw();
+
+  cls = Class::New<Type>();
+  cls.set_is_finalized();
+  cls.set_is_type_finalized();
+  isolate->object_store()->set_type_class(cls);
+
+  Type& type = Type::Handle();
+  cls = dynamic_class_;
+  type = Type::NewNonParameterizedType(cls);
+  dynamic_type_ = type.raw();

[regis, 2013/08/12 21:16:22]

Do you need the type handle? How about:
dynamic_type_ = Type::NewNonParameterizedType(cls);

[rmacnak, 2013/08/12 22:14:53]

Fixed.

+
+  cls = void_class_;
+  type = Type::NewNonParameterizedType(cls);
+  void_type_ = type.raw();

[regis, 2013/08/12 21:16:22]

void_type_ = Type::NewNonParameterizedType(cls);

+
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
   *smi_illegal_cid_ = Smi::New(kIllegalCid);
 
   String& error_str = String::Handle();
   error_str = String::New("SnapshotWriter Error");
@@ skipping 254 matching lines @@
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   String& name = String::Handle();
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
   RegisterClass(cls, Symbols::Bool(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
+  // TODO(12364): The class 'Null' is not registered in the class dictionary
+  // because it is not exported by dart:core.
   cls = Class::New<Instance>(kNullCid);
   cls.set_name(Symbols::Null());
   // We immediately mark Null as finalized because it has no corresponding
   // source.
   cls.set_is_finalized();
   cls.set_is_type_finalized();
   object_store->set_null_class(cls);
   cls.set_library(core_lib);  // A sort of fiction for the mirrors.
   // When/if we promote Null to an ordinary class, it should be added to the
   // core library, given source and added to the list of classes pending
@@ skipping 252 matching lines @@
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_smi_type(type);
 
   cls = object_store->mint_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_mint_type(type);
 
-  // The class 'Null' is not register in the class dictionary because it is not
   // The classes 'void' and 'dynamic' are phoney classes to make type checking
   // more regular; they live in the VM isolate. The class 'void' is not
   // registered in the class dictionary because its name is a reserved word.
   // The class 'dynamic' is registered in the class dictionary because its name
   // is a built-in identifier (this is wrong).
   // The corresponding types are stored in the object store.
   cls = object_store->null_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
   // Consider removing when/if Null becomes an ordinary class.
   type = object_store->object_type();
   cls.set_super_type(type);
 
-  cls = void_class();
-  type = Type::NewNonParameterizedType(cls);
-  object_store->set_void_type(type);
-
-  cls = dynamic_class();
-  type = Type::NewNonParameterizedType(cls);
-  object_store->set_dynamic_type(type);
-
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
   if (!error.IsNull()) {
     return error.raw();
   }
 
   ClassFinalizer::VerifyBootstrapClasses();
   MarkInvisibleFunctions();
 
@@ skipping 1497 matching lines @@
 
 
 RawFunction* Class::LookupFunction(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   ReusableHandleScope reused_handles(isolate);
   Array& funcs = reused_handles.ArrayHandle();
   funcs ^= functions();
-  if (funcs.IsNull()) {
-    // This can occur, e.g., for Null classes.
-    return Function::null();
-  }
+  ASSERT(!funcs.IsNull());
   Function& function = reused_handles.FunctionHandle();
   const intptr_t len = funcs.Length();
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       if (function.name() == name.raw()) {
         return CheckFunctionType(function, type);
       }
@@ skipping 15 matching lines @@
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name,
                                                intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   ReusableHandleScope reused_handles(isolate);
   Array& funcs = reused_handles.ArrayHandle();
   funcs ^= functions();
-  if (funcs.IsNull()) {
-    // This can occur, e.g., for Null classes.
-    return Function::null();
-  }
+  ASSERT(!funcs.IsNull());
   Function& function = reused_handles.FunctionHandle();
   String& function_name = reused_handles.StringHandle();
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (String::EqualsIgnoringPrivateKey(function_name, name)) {
       return CheckFunctionType(function, type);
     }
   }
@@ skipping 80 matching lines @@
 
 
 RawField* Class::LookupField(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Field::null();
   }
   ReusableHandleScope reused_handles(isolate);
   Array& flds = reused_handles.ArrayHandle();
   flds ^= fields();
-  if (flds.IsNull()) {
-    // This can occur, e.g., for Null classes.
-    return Field::null();
-  }
+  ASSERT(!flds.IsNull());
   Field& field = reused_handles.FieldHandle();
   String& field_name = reused_handles.StringHandle();
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
     if (String::EqualsIgnoringPrivateKey(field_name, name)) {
       if (type == kInstance) {
         if (!field.is_static()) {
           return field.raw();
@@ skipping 7643 matching lines @@
 RawString* AbstractType::ClassName() const {
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
 
 
 bool AbstractType::IsNullType() const {
-  return HasResolvedTypeClass() &&
-      (type_class() == Type::Handle(Type::NullType()).type_class());
+  ASSERT(Type::Handle(Type::NullType()).IsCanonical());
+  return raw() == Type::NullType();
 }
 
 
 bool AbstractType::IsBoolType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::BoolType()).type_class());
 }
 
 
 bool AbstractType::IsIntType() const {
@@ skipping 128 matching lines @@
   stream->CloseObject();
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
 RawType* Type::DynamicType() {
-  return Isolate::Current()->object_store()->dynamic_type();
+  return Object::dynamic_type();
 }
 
 
 RawType* Type::VoidType() {
-  return Isolate::Current()->object_store()->void_type();
+  return Object::void_type();
 }
 
 
 RawType* Type::ObjectType() {
   return Isolate::Current()->object_store()->object_type();
 }
 
 
 RawType* Type::BoolType() {
   return Isolate::Current()->object_store()->bool_type();
@@ skipping 3979 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart