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

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 659 matching lines @@
                                   const Library& lib) {
   ASSERT(public_class_name.Length() > 0);
   ASSERT(public_class_name.CharAt(0) == '_');
   String& str = String::Handle();
   str = lib.PrivateName(public_class_name);
   cls.set_name(str);
   lib.AddClass(cls);
 }
 
 
-#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();
 
   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.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
@@ skipping 110 matching lines @@
   RegisterClass(cls, Symbols::StackTrace(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
   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);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = object_store->type_class();
   RegisterPrivateClass(cls, Symbols::Type(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
@@ skipping 30 matching lines @@
   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 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 =
       RawObject::NumberOfTypedDataClasses();
   Array& typed_data_classes =
       Array::Handle(Array::New(typed_data_class_array_length));
   int index = 0;
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
   index = kTypedData##clazz##Cid - kTypedDataInt8ArrayCid;                     \
@@ skipping 58 matching lines @@
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
   cls = Class::New<Number>();
   RegisterClass(cls, Symbols::Number(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   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);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
   type = Type::NewNonParameterizedType(cls);
@@ skipping 18 matching lines @@
   // 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.
-  INIT_LIBRARY(Core, core, true);
-
-  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();
+  const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
+  if (!error.IsNull()) {
+    return error.raw();
+  }
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
   cls.set_super_type(Type::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
   MarkInvisibleFunctions();
 
   // Set up the intrinsic state of all functions (core, math and scalar list).
@@ skipping 764 matching lines @@
   result.raw_ptr()->state_bits_ = 0;
   result.raw_ptr()->type_arguments_field_offset_in_words_ = 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) {
-  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);
   return result.raw();
 }
 
 
-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.
   result.set_instance_size(Closure::InstanceSize());
   result.set_next_field_offset(Closure::InstanceSize());
   result.set_super_type(super_type);
   result.set_type_arguments_field_offset(Closure::type_arguments_offset());
   // Implements interface "Function".
   const Type& function_type = Type::Handle(Type::Function());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
@@ skipping 34 matching lines @@
   }
   set_is_prefinalized();
 }
 
 
 RawClass* Class::NewNativeWrapper(const Library& library,
                                   const String& name,
                                   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.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
     intptr_t instance_size = sizeof(RawObject) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
@@ skipping 4505 matching lines @@
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 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);
+  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
   // 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()));
 }
 
 
@@ skipping 6726 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart