VM: Support bootstrapping core libraries from Kernel binaries instead of source.

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define I (isolate_)
 #define T (type_translator_)
 #define H (translation_helper_)
 
 class SimpleExpressionConverter : public ExpressionVisitor {
  public:
@@ skipping 49 matching lines @@
   const dart::Instance& SimpleValue() { return *simple_value_; }
   dart::Zone* zone() const { return zone_; }
 
  private:
   TranslationHelper translation_helper_;
   dart::Zone* zone_;
   bool is_simple_;
   dart::Instance* simple_value_;
 };
 
-void BuildingTranslationHelper::SetFinalize(bool finalize) {
-  reader_->finalize_ = finalize;
-}
 
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     Library* library) {
   return reader_->LookupLibrary(library).raw();
 }
 
+
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(Class* klass) {
   return reader_->LookupClass(klass).raw();
 }
 
+
 Object& KernelReader::ReadProgram() {
   ASSERT(!bootstrapping_);
   Program* program = ReadPrecompiledKernelFromBuffer(buffer_, buffer_length_);
   if (program == NULL) {
     const dart::String& error = H.DartString("Failed to read .kernell file");
     return Object::Handle(Z, ApiError::New(error));
   }
 
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Procedure* main = program->main_method();
     Library* kernel_main_library = Library::Cast(main->parent());
 
     intptr_t length = program->libraries().length();
     for (intptr_t i = 0; i < length; i++) {
       Library* kernel_library = program->libraries()[i];
       ReadLibrary(kernel_library);
     }
 
-    // We finalize classes after we've constructed all classes since we
-    // currently don't construct them in pre-order of the class hierarchy (and
-    // finalization of a class needs all of its superclasses to be finalized).
-    dart::String& name = dart::String::Handle(Z);
     for (intptr_t i = 0; i < length; i++) {
-      Library* kernel_library = program->libraries()[i];
-      dart::Library& library = LookupLibrary(kernel_library);
-      name = library.url();
+      dart::Library& library = LookupLibrary(program->libraries()[i]);
+      if (!library.Loaded()) library.SetLoaded();
+    }
 
-      // TODO(27590) unskip this library when we fix underlying issue.
-      if (name.Equals("dart:vmservice_io")) {
-        continue;
-      }
-
-      if (!library.Loaded()) {
-        dart::Class& klass = dart::Class::Handle(Z);
-        for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
-          klass = LookupClass(kernel_library->classes()[i]).raw();
-          ClassFinalizer::FinalizeTypesInClass(klass);
-          ClassFinalizer::FinalizeClass(klass);
-        }
-        library.SetLoaded();
-      }
+    if (!ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
+      FATAL("Error in class finalization during bootstrapping.");
     }
 
     dart::Library& library = LookupLibrary(kernel_main_library);
 
     // Sanity check that we can find the main entrypoint.
     Object& main_obj = Object::Handle(
         Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
     ASSERT(!main_obj.IsNull());
     return library;
   } else {
     // Everything else is a compile-time error. We don't use the [error] since
     // it sometimes causes the higher-level error handling to try to read the
     // script and token position (which we don't have) to produce a nice error
     // message.
     Error& error = Error::Handle(Z);
     error = thread_->sticky_error();
     thread_->clear_sticky_error();
 
     // Instead we simply make a non-informative error message.
     const dart::String& error_message =
         H.DartString("Failed to read .kernell file => CompileTimeError.");
     return Object::Handle(Z, LanguageError::New(error_message));
   }
 }
 
+
 void KernelReader::ReadLibrary(Library* kernel_library) {
   dart::Library& library = LookupLibrary(kernel_library);
   if (library.Loaded()) return;
 
   // The bootstrapper will take care of creating the native wrapper classes, but
   // we will add the synthetic constructors to them here.
   if (library.name() ==
       Symbols::Symbol(Symbols::kDartNativeWrappersLibNameId).raw()) {
     ASSERT(library.LoadInProgress());
   } else {
@@ skipping 36 matching lines @@
     toplevel_class.AddField(field);
     library.AddObject(field, name);
   }
 
   // Load toplevel procedures.
   for (intptr_t i = 0; i < kernel_library->procedures().length(); i++) {
     Procedure* kernel_procedure = kernel_library->procedures()[i];
     ReadProcedure(library, toplevel_class, kernel_procedure);
   }
 
+  const GrowableObjectArray& classes =
+      GrowableObjectArray::Handle(I->object_store()->pending_classes());
+
   // Load all classes.
   for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
     Class* kernel_klass = kernel_library->classes()[i];
-    ReadClass(library, kernel_klass);
+    classes.Add(ReadClass(library, kernel_klass), Heap::kOld);
   }
 }
 
+
 void KernelReader::ReadPreliminaryClass(dart::Class* klass,
                                         Class* kernel_klass) {
   ASSERT(kernel_klass->IsNormalClass());
   NormalClass* kernel_normal_class = NormalClass::Cast(kernel_klass);
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, klass);
 
   // First setup the type parameters, so if any of the following code uses it
   // (in a recursive way) we're fine.
   TypeArguments& type_parameters =
@@ skipping 40 matching lines @@
     AbstractType& super_type =
         T.TranslateTypeWithoutFinalization(kernel_normal_class->super_class());
     if (super_type.IsMalformed()) H.ReportError("Malformed super type");
     klass->set_super_type(super_type);
   }
 
   // Build implemented interface types
   intptr_t interface_count = kernel_klass->implemented_classes().length();
   const dart::Array& interfaces =
       dart::Array::Handle(Z, dart::Array::New(interface_count));
-  dart::Class& interface_class = dart::Class::Handle(Z);
   for (intptr_t i = 0; i < interface_count; i++) {
     InterfaceType* kernel_interface_type =
         kernel_klass->implemented_classes()[i];
     const AbstractType& type =
         T.TranslateTypeWithoutFinalization(kernel_interface_type);
     if (type.IsMalformed()) H.ReportError("Malformed interface type.");
     interfaces.SetAt(i, type);
-
-    // NOTE: Normally the DartVM keeps a list of pending classes and iterates
-    // through them later on using `ClassFinalizer::ProcessPendingClasses()`.
-    // This involes calling `ClassFinalizer::ResolveSuperTypeAndInterfaces()`
-    // which does a lot of error validation (e.g. cycle checks) which we don't
-    // need here.  But we do need to do one thing which this resolving phase
-    // normally does for us: set the `is_implemented` boolean.
-
-    // TODO(27590): Maybe we can do this differently once we have
-    // "bootstrapping from kernel"-support.
-    interface_class = type.type_class();
-    interface_class.set_is_implemented();
   }
   klass->set_interfaces(interfaces);
   if (kernel_klass->is_abstract()) klass->set_is_abstract();
-  klass->set_is_cycle_free();
-
-  // When bootstrapping we should not finalize types yet because they will be
-  // finalized when the object store's pending_classes list is drained by
-  // ClassFinalizer::ProcessPendingClasses.  Even when not bootstrapping we are
-  // careful not to eagerly finalize types that may introduce a circularity
-  // (such as type arguments, interface types, field types, etc.).
-  if (finalize_) ClassFinalizer::FinalizeTypesInClass(*klass);
 }
 
-void KernelReader::ReadClass(const dart::Library& library,
-                             Class* kernel_klass) {
+
+dart::Class& KernelReader::ReadClass(const dart::Library& library,
+                                     Class* kernel_klass) {
   // This will trigger a call to [ReadPreliminaryClass] if not already done.
   dart::Class& klass = LookupClass(kernel_klass);
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
 
   TokenPosition pos(0);
 
   for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
     Field* kernel_field = kernel_klass->fields()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_field);
@@ skipping 44 matching lines @@
     Procedure* kernel_procedure = kernel_klass->procedures()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
     ReadProcedure(library, klass, kernel_procedure, kernel_klass);
   }
 
   if (bootstrapping_ && !klass.is_marked_for_parsing()) {
     klass.set_is_marked_for_parsing();
     GrowableObjectArray::Handle(Z, I->object_store()->pending_classes())
         .Add(klass, Heap::kOld);
   }
+
+  return klass;
 }
 
+
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  Procedure* kernel_procedure,
                                  Class* kernel_klass) {
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &owner);
   ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
   ActiveFunctionScope active_function_scope(&active_class_,
                                             kernel_procedure->function());
 
   const dart::String& name = H.DartProcedureName(kernel_procedure);
@@ skipping 119 matching lines @@
                          false,  // is_native
                          klass, pos));
     klass.AddFunction(setter);
     setter.set_kernel_function(kernel_field);
     setter.set_result_type(Object::void_type());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
+
 void KernelReader::SetupFunctionParameters(TranslationHelper translation_helper,
                                            DartTypeTranslator type_translator,
                                            const dart::Class& klass,
                                            const dart::Function& function,
                                            FunctionNode* node,
                                            bool is_method,
                                            bool is_closure) {
   dart::Zone* zone = translation_helper.zone();
 
   ASSERT(!(is_method && is_closure));
@@ skipping 50 matching lines @@
     function.SetParameterNameAt(
         pos, translation_helper.DartSymbol(named_expression->name()));
   }
 
   const AbstractType& return_type =
       type_translator.TranslateType(node->return_type());
   function.set_result_type(return_type.IsMalformed() ? Type::dynamic_type()
                                                      : return_type);
 }
 
+
 void KernelReader::SetupFieldAccessorFunction(const dart::Class& klass,
                                               const dart::Function& function) {
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   intptr_t num_parameters = (is_method ? 1 : 0) + (is_setter ? 1 : 0);
 
   function.SetNumOptionalParameters(0, false);
   function.set_num_fixed_parameters(num_parameters);
   function.set_parameter_types(
       Array::Handle(Z, Array::New(num_parameters, Heap::kOld)));
@@ skipping 65 matching lines @@
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
     classes_.Insert(klass, handle);
     if (!handle->is_type_finalized()) {
       ReadPreliminaryClass(handle, klass);
     }
   }
   return *handle;
 }
 
+
 RawFunction::Kind KernelReader::GetFunctionType(Procedure* kernel_procedure) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
       RawFunction::kGetterFunction,   // Procedure::kGetter
       RawFunction::kSetterFunction,   // Procedure::kSetter
       RawFunction::kRegularFunction,  // Procedure::kOperator
       RawFunction::kConstructor,      // Procedure::kFactory
   };
   intptr_t kind = static_cast<int>(kernel_procedure->kind());
   if (kind == Procedure::kIncompleteProcedure) {
     return RawFunction::kSignatureFunction;
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
+
 }  // namespace kernel
 }  // namespace dart
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)