VM: [Kernel] Cherry-pick from dart-lang/kernel_sdk

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"
@@ skipping 85 matching lines @@
 Program* KernelReader::ReadPrecompiledProgram() {
   Program* program = ReadPrecompiledKernelFromBuffer(buffer_, buffer_length_);
   if (program == NULL) return NULL;
   intptr_t source_file_count = program->line_starting_table().size();
   scripts_ = Array::New(source_file_count);
   program_ = program;
   return program;
 }
 
 Object& KernelReader::ReadProgram() {
-  ASSERT(!bootstrapping_);
-  Program* program = ReadPrecompiledProgram();
+  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());
 
@@ skipping 49 matching lines @@
     library.SetLoadInProgress();
   }
   // Setup toplevel class (which contains library fields/procedures).
 
   Script& script = ScriptAt(kernel_library->source_uri_index());
   dart::Class& toplevel_class = dart::Class::Handle(
       Z, dart::Class::New(library, Symbols::TopLevel(), script,
                           TokenPosition::kNoSource));
   toplevel_class.set_is_cycle_free();
   library.set_toplevel_class(toplevel_class);
-  if (bootstrapping_) {
-    GrowableObjectArray::Handle(Z, I->object_store()->pending_classes())
-        .Add(toplevel_class, Heap::kOld);
-  }
 
   ActiveClassScope active_class_scope(&active_class_, NULL, &toplevel_class);
   // Load toplevel fields.
   for (intptr_t i = 0; i < kernel_library->fields().length(); i++) {
     Field* kernel_field = kernel_library->fields()[i];
 
     ActiveMemberScope active_member_scope(&active_class_, kernel_field);
     const dart::String& name = H.DartFieldName(kernel_field->name());
     const Object& script_class =
         ClassForScriptAt(toplevel_class, kernel_field->source_uri_index());
@@ skipping 17 matching lines @@
   }
 
   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];
     classes.Add(ReadClass(library, kernel_klass), Heap::kOld);
   }
+
+  classes.Add(toplevel_class, 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);
 
@@ skipping 115 matching lines @@
                             true,    // is_method
                             false);  // is_closure
   }
 
   for (intptr_t i = 0; i < kernel_klass->procedures().length(); i++) {
     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()) {
+  if (!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) {
@@ skipping 298 matching lines @@
     } else if (handle->script() == Script::null()) {
       // When bootstrapping we can encounter classes that do not yet have a
       // dummy script.
       Script& script = ScriptAt(klass->source_uri_index());
       handle->set_script(script);
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // 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()) {
+    if (!handle->is_cycle_free()) {
       ReadPreliminaryClass(handle, klass);
     }
   }
   return *handle;
 }
 
 
 RawFunction::Kind KernelReader::GetFunctionType(Procedure* kernel_procedure) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
@@ skipping 37 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)