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 152 matching lines @@
   Script& script =
       Script::Handle(Z, Script::New(Symbols::KernelScriptUri(),
                                     Symbols::Empty(), RawScript::kScriptTag));
   script.SetLocationOffset(0, 0);
   script.Tokenize(H.DartString("nop() {}"));
   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());
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::NewTopLevel(name, kernel_field->IsFinal(),
@@ skipping 13 matching lines @@
     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];
     classes.Add(ReadClass(library, kernel_klass), Heap::kOld);

[Kevin Millikin (Google), 2016/11/21 15:00:11]

When bootstrapping, ReadClass is also adding classes to the pending class list. 
I guess that's safe but it does extra work and grows the pending class list too
much.

I think the only purpose of the bootstrapping_ flag was to know if we should
finalize classes more or less eagerly.  It probably isn't needed any more.

[kustermann, 2016/11/21 15:30:05]

Good point. Done.

   }
+
+  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 416 matching lines @@
       TokenPosition pos(0);
       Script& script = Script::Handle(
           Z, Script::New(Symbols::KernelScriptUri(), Symbols::Empty(),
                          RawScript::kScriptTag));
       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
       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)