First step towards loading the core library scripts directly from the sources

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 22152)
+++ runtime/vm/object.cc	(working copy)
@@ -677,31 +677,6 @@
 }
 
 
-#define LOAD_LIBRARY(name, raw_name)                                           \
-  url = Symbols::Dart##name().raw();                                           \
-  lib = Library::LookupLibrary(url);                                           \
-  if (lib.IsNull()) {                                                          \
-    lib = Library::NewLibraryHelper(url, true);                                \
-    lib.Register();                                                            \
-  }                                                                            \
-  isolate->object_store()->set_##raw_name##_library(lib);                      \
-
-#define INIT_LIBRARY(name, raw_name, has_patch)                                \
-  LOAD_LIBRARY(name, raw_name)                                                 \
-  script = Bootstrap::Load##name##Script(false);                               \
-  error = Bootstrap::Compile(lib, script);                                     \
-  if (!error.IsNull()) {                                                       \
-    return error.raw();                                                        \
-  }                                                                            \
-  if (has_patch) {                                                             \
-    script = Bootstrap::Load##name##Script(true);                              \
-    error = lib.Patch(script);                                                 \
-    if (!error.IsNull()) {                                                     \
-      return error.raw();                                                      \
-    }                                                                          \
-  }                                                                            \
-
-
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
@@ -709,10 +684,7 @@
   Class& cls = Class::Handle();
   Type& type = Type::Handle();
   Array& array = Array::Handle();
-  String& url = String::Handle();
   Library& lib = Library::Handle();
-  Script& script = Script::Handle();
-  Error& error = Error::Handle();
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
@@ -843,13 +815,14 @@
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
-  script = Bootstrap::LoadCoreScript(false);
 
   // Allocate and initialize the pre-allocated classes in the core library.
+  // The script and token index of these pre-allocated classes is set up in
+  // the parser when the corelib script is compiled (see
+  // Parser::ParseClassDefinition).
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
   cls.set_name(Symbols::Object());
-  cls.set_script(script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
@@ -900,7 +873,13 @@
 
   // Pre-register the typed_data library so the native class implementations
   // can be hooked up before compiling it.
-  LOAD_LIBRARY(TypedData, typed_data);
+  lib = Library::LookupLibrary(Symbols::DartTypedData());
+  if (lib.IsNull()) {
+    lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
+    lib.Register();
+    isolate->object_store()->set_bootstrap_library(ObjectStore::kTypedData,
+                                                   lib);
+  }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
   const intptr_t typed_data_class_array_length =
@@ -979,30 +958,26 @@
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_type(type);
 
-  cls = Class::New<Instance>(Symbols::Int(), script, Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Int(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
-  cls = Class::New<Instance>(Symbols::Double(),
-                             script,
-                             Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
-  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
-  cls = Class::New<Instance>(Symbols::List(),
-                             script,
-                             Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::List(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   object_store->set_list_class(cls);
@@ -1041,22 +1016,11 @@
 
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
-  INIT_LIBRARY(Core, core, true);
+  const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
+  if (!error.IsNull()) {
+    return error.raw();
+  }
 
-  INIT_LIBRARY(Async, async, true);
-  INIT_LIBRARY(Collection, collection, true);
-  INIT_LIBRARY(CollectionDev, collection_dev, true);
-  INIT_LIBRARY(Crypto, crypto, false);
-  INIT_LIBRARY(Isolate, isolate, true);
-  INIT_LIBRARY(Json, json, true);
-  INIT_LIBRARY(Math, math, true);
-  INIT_LIBRARY(Mirrors, mirrors, true);
-  INIT_LIBRARY(TypedData, typed_data, true);
-  INIT_LIBRARY(Utf, utf, false);
-  INIT_LIBRARY(Uri, uri, false);
-
-  Bootstrap::SetupNativeResolver();
-
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
@@ -1840,11 +1804,10 @@
 }
 
 
-template <class FakeInstance>
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
-  Class& result = Class::Handle(New<FakeInstance>(kIllegalCid));
+  Class& result = Class::Handle(New<Instance>(kIllegalCid));
   result.set_name(name);
   result.set_script(script);
   result.set_token_pos(token_pos);
@@ -1852,19 +1815,11 @@
 }
 
 
-RawClass* Class::New(const String& name,
-                     const Script& script,
-                     intptr_t token_pos) {
-  Class& result = Class::Handle(New<Instance>(name, script, token_pos));
-  return result.raw();
-}
-
-
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_pos) {
-  const Class& result = Class::Handle(New<Instance>(name, script, token_pos));
+  const Class& result = Class::Handle(New(name, script, token_pos));
   const Type& super_type = Type::Handle(Type::ObjectType());
   ASSERT(!super_type.IsNull());
   // Instances of a signature class can only be closures.
@@ -1919,7 +1874,7 @@
                                   int field_count) {
   Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
-    cls = New<Instance>(name, Script::Handle(), Scanner::kDummyTokenIndex);
+    cls = New(name, Script::Handle(), Scanner::kDummyTokenIndex);
     cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
@@ -6445,7 +6400,7 @@
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
-  isolate->object_store()->set_core_library(core_lib);
+  isolate->object_store()->set_bootstrap_library(ObjectStore::kCore, core_lib);
   isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These