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

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
+
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
@@ skipping 177 matching lines @@
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
 
   Zone* zone() { return zone_; }
 
   Isolate* isolate() { return isolate_; }
 
   Heap::Space allocation_space() { return allocation_space_; }
 
-  // Set whether unfinalized classes should be finalized.  The base class
-  // implementation used at flow graph construction time looks up classes in the
-  // VM's heap, all of which should already be finalized.
-  virtual void SetFinalize(bool finalize) {}
-
   RawInstance* Canonicalize(const Instance& instance);
 
   const dart::String& DartString(const char* content) {
     return DartString(content, allocation_space_);
   }
   const dart::String& DartString(const char* content, Heap::Space space);
 
   dart::String& DartString(String* content) {
     return DartString(content, allocation_space_);
   }
@@ skipping 14 matching lines @@
   const dart::String& DartFactoryName(Class* klass, Name* kernel_name);
 
   const Array& ArgumentNames(List<NamedExpression>* named);
 
   // A subclass overrides these when reading in the Kernel program in order to
   // support recursive type expressions (e.g. for "implements X" ...
   // annotations).
   virtual RawLibrary* LookupLibraryByKernelLibrary(Library* library);
   virtual RawClass* LookupClassByKernelClass(Class* klass);
 
+  RawUnresolvedClass* ToUnresolvedClass(Class* klass);
+
   RawField* LookupFieldByKernelField(Field* field);
   RawFunction* LookupStaticMethodByKernelProcedure(Procedure* procedure);
   RawFunction* LookupConstructorByKernelConstructor(Constructor* constructor);
   dart::RawFunction* LookupConstructorByKernelConstructor(
       const dart::Class& owner,
       Constructor* constructor);
 
   dart::Type& GetCanonicalType(const dart::Class& klass);
 
   void ReportError(const char* format, ...);
@@ skipping 21 matching lines @@
 //     * T is a parametrized Type G<T1, ...> and G is malformed
 //     * T denotes declarations from multiple imports
 //
 // Any use of a malformed type gives rise to a static warning.  A malformed
 // type is then interpreted as dynamic by the static type checker and the
 // runtime unless explicitly specified otherwise.
 class DartTypeTranslator : public DartTypeVisitor {
  public:
   DartTypeTranslator(TranslationHelper* helper,
                      ActiveClass* active_class,
-                     bool finalize = true)
+                     bool finalize = false)
       : translation_helper_(*helper),
         active_class_(active_class),
         zone_(helper->zone()),
         result_(AbstractType::Handle(helper->zone())),
         finalize_(finalize) {}
 
   // Can return a malformed type.
   AbstractType& TranslateType(DartType* node);
 
   // Can return a malformed type.
@@ skipping 198 matching lines @@
 
 
 class ScopeBuilder : public RecursiveVisitor {
  public:
   ScopeBuilder(ParsedFunction* parsed_function, TreeNode* node)
       : result_(NULL),
         parsed_function_(parsed_function),
         node_(node),
         zone_(Thread::Current()->zone()),
         translation_helper_(Thread::Current(), zone_, Isolate::Current()),
-        type_translator_(&translation_helper_, &active_class_),
+        type_translator_(&translation_helper_,
+                         &active_class_,
+                         /*finalize=*/ true),
         current_function_scope_(NULL),
         scope_(NULL),
         depth_(0),
         name_index_(0) {}
 
   virtual ~ScopeBuilder() {}
 
   ScopeBuildingResult* BuildScopes();
 
   virtual void VisitName(Name* node) { /* NOP */
@@ skipping 397 matching lines @@
   friend class DartTypeTranslator;
   friend class ScopeBuilder;
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
-
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_