Move Null class out of the VM isolate.

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 74 matching lines @@
 Instance* Object::unknown_constant_ = NULL;
 Instance* Object::non_constant_ = NULL;
 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::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(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);
@@ skipping 303 matching lines @@
         Class::kNoTypeArguments;
     cls.raw_ptr()->num_native_fields_ = 0;
     cls.InitEmptyFields();
     isolate->RegisterClass(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullCid);
   cls.set_is_finalized();
   cls.set_is_type_finalized();
-  null_class_ = cls.raw();
+  isolate->object_store()->set_null_class(cls);
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
   cls.set_is_finalized();
   cls.set_is_type_finalized();
 
   // Allocate and initialize the sentinel values of Null class.
   {
     *sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
@@ skipping 184 matching lines @@
 
 #define SET_CLASS_NAME(class_name, name)                                       \
   cls = class_name##_class();                                                  \
   cls.set_name(Symbols::name());                                               \
 
 void Object::RegisterSingletonClassNames() {
   Class& cls = Class::Handle();
 
   // Set up names for all VM singleton classes.
   SET_CLASS_NAME(class, Class);
-  SET_CLASS_NAME(null, Null);
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
   SET_CLASS_NAME(unresolved_class, UnresolvedClass);
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
   SET_CLASS_NAME(closure_data, ClosureData);
   SET_CLASS_NAME(redirection_data, RedirectionData);
   SET_CLASS_NAME(field, Field);
@@ skipping 200 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);
 
+  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
+  // finalization.
+  // RegisterClass(cls, Symbols::Null(), core_lib);
+  // pending_classes.Add(cls, Heap::kOld);
+
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::ObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   type ^= Type::New(Object::Handle(cls.raw()),
                     TypeArguments::Handle(),
                     Scanner::kDummyTokenIndex);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
@@ skipping 238 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 classes 'Null' and 'void' are not registered in the class dictionary,
-  // because their names are reserved keywords. Their names are not heap
-  // allocated, because the classes reside in the VM isolate.
+  // The class 'Null' is not register in the class dictionary because it is not

[siva, 2013/08/10 00:43:34]

registered, the comment also doesn't seem correct.

+  // 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).

[siva, 2013/08/10 00:43:34]

Maybe you should add an issue to track this and add a TODO here.

   // The corresponding types are stored in the object store.
-  cls = null_class();
+  cls = object_store->null_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
+  // Consider removing when/if Null becomes an ordinary class.

[siva, 2013/08/10 00:43:34]

I think this should also have an issue and a TODO (probably in sync with comment
above about Null class being added to the pending_classes list.

+  type = object_store->object_type();
+  cls.set_super_type(type);
+
   cls = void_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_void_type(type);
 
-  // The class 'dynamic' is registered in the class dictionary because its name
-  // is a built-in identifier, rather than a reserved keyword. Its name is not
-  // heap allocated, because the class resides in the VM isolate.
-  // The corresponding type, the "unknown type", is stored in the object store.
   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();
   }
@@ skipping 84 matching lines @@
 
   cls = Class::NewStringClass(kExternalOneByteStringCid);
   object_store->set_external_one_byte_string_class(cls);
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
+  cls = Class::New<Instance>(kNullCid);
+  object_store->set_null_class(cls);
+
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
 
   // Some classes are not stored in the object store. Yet we still need to
   // create their Class object so that they get put into the class_table
   // (as a side effect of Class::New()).
   cls = Class::New<DartFunction>();
@@ skipping 9203 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());

[siva, 2013/08/10 00:43:34]

This has become an expensive operation now with the need to create
a Handle inside of the function.

Wouldn't the NullType be always canonicalized and we could just compare the type
objects?

+}
+
+
 bool AbstractType::IsBoolType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::BoolType()).type_class());
 }
 
 
 bool AbstractType::IsIntType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::IntType()).type_class());
 }
@@ skipping 4130 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart