- Properly load the core libraries as libraries and not as scripts.

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/bigint_operations.h"
@@ skipping 680 matching lines @@
   object_store->set_two_byte_string_class(cls);
 
   // Setup the symbol table for the symbols created in the isolate.
   Symbols::SetupSymbolTable(isolate);
 
   // Set up the libraries array before initializing the core library.
   const GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_libraries(libraries);
 
+  // Pre-register the core library.
+  Library::InitCoreLibrary(isolate);
+
   // Basic infrastructure has been setup, initialize the class dictionary.
-  Library::InitCoreLibrary(isolate);
   Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
 
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_pending_classes(pending_classes);
 
   Context& context = Context::Handle(Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
@@ skipping 101 matching lines @@
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
   RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
+  // Setup some default native field classes which can be extended for
+  // specifying native fields in dart classes.
+  Library::InitNativeWrappersLibrary(isolate);
+  ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
+
+  // Pre-register the remaining internal librarie.
+  Library::InitAsyncLibrary(isolate);
+  Library::InitCollectionLibrary(isolate);
+  Library::InitCollectionDevLibrary(isolate);
+  Library::InitMathLibrary(isolate);
+  Library::InitIsolateLibrary(isolate);
+  Library::InitMirrorsLibrary(isolate);
   Library::InitScalarlistLibrary(isolate);

[siva, 2013/02/23 00:11:03]

When we clean up the library init stuff some of this may move around. As
discussed we could do that in another CL.

[Ivan Posva, 2013/02/25 22:20:14]

Already cleaned up.

+
   Library& scalarlist_lib = Library::Handle(Library::ScalarlistLibrary());
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Int8Array(), scalarlist_lib);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint8Array(), scalarlist_lib);
 
@@ skipping 151 matching lines @@
   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);
 
-  // Setup some default native field classes which can be extended for
-  // specifying native fields in dart classes.
-  Library::InitNativeWrappersLibrary(isolate);
-  ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
-
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   Error& error = Error::Handle();
   error = Bootstrap::Compile(core_lib, script);
   if (!error.IsNull()) {
     return error.raw();
   }
   Script& patch_script = Script::Handle(Bootstrap::LoadCoreScript(true));
   error = core_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
   }
-  Library::InitASyncLibrary(isolate);
   const Script& async_script =
-      Script::Handle(Bootstrap::LoadASyncScript(false));
-  const Library& async_lib = Library::Handle(Library::ASyncLibrary());
+      Script::Handle(Bootstrap::LoadAsyncScript(false));
+  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
   ASSERT(!async_lib.IsNull());
   error = Bootstrap::Compile(async_lib, async_script);
   if (!error.IsNull()) {
     return error.raw();
   }
-  patch_script = Bootstrap::LoadASyncScript(true);
+  patch_script = Bootstrap::LoadAsyncScript(true);
   error = async_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   const Script& collection_script =
       Script::Handle(Bootstrap::LoadCollectionScript(false));
   const Library& collection_lib =
       Library::Handle(Library::CollectionLibrary());
   ASSERT(!collection_lib.IsNull());
   error = Bootstrap::Compile(collection_lib, collection_script);
@@ skipping 16 matching lines @@
   if (!error.IsNull()) {
     return error.raw();
   }
   patch_script = Bootstrap::LoadMathScript(true);
   error = math_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   const Script& isolate_script = Script::Handle(
       Bootstrap::LoadIsolateScript(false));
-  Library::InitIsolateLibrary(isolate);
   const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   error = Bootstrap::Compile(isolate_lib, isolate_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   patch_script = Bootstrap::LoadIsolateScript(true);
   error = isolate_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   const Script& mirrors_script = Script::Handle(
       Bootstrap::LoadMirrorsScript(false));
-  Library::InitMirrorsLibrary(isolate);
   const Library& mirrors_lib = Library::Handle(Library::MirrorsLibrary());
   ASSERT(!mirrors_lib.IsNull());
   error = Bootstrap::Compile(mirrors_lib, mirrors_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   patch_script = Bootstrap::LoadMirrorsScript(true);
   error = mirrors_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
@@ skipping 5249 matching lines @@
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
-void Library::InitASyncLibrary(Isolate* isolate) {
+void Library::InitAsyncLibrary(Isolate* isolate) {
   const String& url = Symbols::DartAsync();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   isolate->object_store()->set_async_library(lib);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = Symbols::DartCore();
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
   isolate->object_store()->set_core_library(core_lib);
-  Library::InitMathLibrary(isolate);
-  const Library& math_lib = Library::Handle(Library::MathLibrary());
-  const Namespace& math_ns = Namespace::Handle(
-      Namespace::New(math_lib, Array::Handle(), Array::Handle()));
-  Library::InitCollectionDevLibrary(isolate);
-  const Library& collection_dev_lib =
-      Library::Handle(Library::CollectionDevLibrary());
-  const Namespace& collection_dev_ns = Namespace::Handle(
-      Namespace::New(collection_dev_lib, Array::Handle(), Array::Handle()));
-  Library::InitCollectionLibrary(isolate);
-  const Library& collection_lib =
-      Library::Handle(Library::CollectionLibrary());
-  const Namespace& collection_ns = Namespace::Handle(
-      Namespace::New(collection_lib, Array::Handle(), Array::Handle()));
-  core_lib.AddImport(math_ns);
-  core_lib.AddImport(collection_ns);
-  core_lib.AddImport(collection_dev_ns);
   isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 void Library::InitCollectionLibrary(Isolate* isolate) {
   const String& url = Symbols::DartCollection();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& math_lib = Library::Handle(Library::MathLibrary());
-  const Namespace& math_ns = Namespace::Handle(
-      Namespace::New(math_lib, Array::Handle(), Array::Handle()));
-  const Library& collection_dev_lib =
-      Library::Handle(Library::CollectionDevLibrary());
-  const Namespace& collection_dev_ns = Namespace::Handle(
-      Namespace::New(collection_dev_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(math_ns);
-  lib.AddImport(collection_dev_ns);
   isolate->object_store()->set_collection_library(lib);
 }
 
 
 void Library::InitCollectionDevLibrary(Isolate* isolate) {
   const String& url = Symbols::DartCollectionDev();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   isolate->object_store()->set_collection_dev_library(lib);
 }
 
 
 void Library::InitCryptoLibrary(Isolate* isolate) {
   const String& url = Symbols::DartCrypto();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& math_lib = Library::Handle(Library::MathLibrary());
-  const Namespace& math_ns = Namespace::Handle(
-      Namespace::New(math_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(math_ns);
   isolate->object_store()->set_crypto_library(lib);
 }
 
 
 void Library::InitIsolateLibrary(Isolate* isolate) {
   const String& url = Symbols::DartIsolate();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& async_lib = Library::Handle(Library::ASyncLibrary());
-  const Namespace& async_ns = Namespace::Handle(
-      Namespace::New(async_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(async_ns);
   isolate->object_store()->set_isolate_library(lib);
 }
 
 
 void Library::InitJsonLibrary(Isolate* isolate) {
   const String& url = Symbols::DartJson();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   isolate->object_store()->set_json_library(lib);
 }
 
 
 void Library::InitMathLibrary(Isolate* isolate) {
   const String& url = Symbols::DartMath();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   isolate->object_store()->set_math_library(lib);
 }
 
 
 void Library::InitMirrorsLibrary(Isolate* isolate) {
   const String& url = Symbols::DartMirrors();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
-  const Namespace& isolate_ns = Namespace::Handle(
-      Namespace::New(isolate_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(isolate_ns);
-  const Library& async_lib = Library::Handle(Library::ASyncLibrary());
-  const Namespace& async_ns = Namespace::Handle(
-      Namespace::New(async_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(async_ns);
   const Library& wrappers_lib =
-      Library::Handle(Library::NativeWrappersLibrary());
+  Library::Handle(Library::NativeWrappersLibrary());
   const Namespace& wrappers_ns = Namespace::Handle(
       Namespace::New(wrappers_lib, Array::Handle(), Array::Handle()));
   lib.AddImport(wrappers_ns);
   isolate->object_store()->set_mirrors_library(lib);
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
@@ skipping 16 matching lines @@
     cls_name = Symbols::New(name_buffer);
     Class::NewNativeWrapper(native_flds_lib, cls_name, fld_cnt);
   }
 }
 
 
 void Library::InitScalarlistLibrary(Isolate* isolate) {
   const String& url = Symbols::DartScalarlist();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& collection_lib =
-      Library::Handle(Library::CollectionLibrary());
-  const Namespace& collection_ns = Namespace::Handle(
-      Namespace::New(collection_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(collection_ns);
   isolate->object_store()->set_scalarlist_library(lib);
 }
 
 
 void Library::InitUriLibrary(Isolate* isolate) {
   const String& url = Symbols::DartUri();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& math_lib = Library::Handle(Library::MathLibrary());
-  const Namespace& math_ns = Namespace::Handle(
-      Namespace::New(math_lib, Array::Handle(), Array::Handle()));
-  const Library& utf_lib = Library::Handle(Library::UtfLibrary());
-  const Namespace& utf_ns = Namespace::Handle(
-      Namespace::New(utf_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(math_ns);
-  lib.AddImport(utf_ns);
   isolate->object_store()->set_uri_library(lib);
 }
 
 
 void Library::InitUtfLibrary(Isolate* isolate) {
   const String& url = Symbols::DartUtf();
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
-  const Library& async_lib = Library::Handle(Library::ASyncLibrary());
-  const Namespace& async_ns = Namespace::Handle(
-      Namespace::New(async_lib, Array::Handle(), Array::Handle()));
-  lib.AddImport(async_ns);
   isolate->object_store()->set_utf_library(lib);
 }
 
 
 RawLibrary* Library::LookupLibrary(const String &url) {
   Isolate* isolate = Isolate::Current();
   Library& lib = Library::Handle(isolate, Library::null());
   String& lib_url = String::Handle(isolate, String::null());
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
       isolate, isolate->object_store()->libraries());
@@ skipping 77 matching lines @@
   ASSERT(Library::LookupLibrary(String::Handle(url())) == Library::null());
   ObjectStore* object_store = Isolate::Current()->object_store();
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store->libraries());
   ASSERT(!libs.IsNull());
   set_index(libs.Length());
   libs.Add(*this);
 }
 
 
-RawLibrary* Library::ASyncLibrary() {
+RawLibrary* Library::AsyncLibrary() {
   return Isolate::Current()->object_store()->async_library();
 }
 
 
 RawLibrary* Library::CoreLibrary() {
   return Isolate::Current()->object_store()->core_library();
 }
 
 
 RawLibrary* Library::CollectionLibrary() {
@@ skipping 6352 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart