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

runtime/vm/kernel_to_il.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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel_reader.h"
 #include "vm/longjump.h"
 #include "vm/method_recognizer.h"
 #include "vm/object_store.h"
 #include "vm/report.h"
 #include "vm/resolver.h"
 #include "vm/stack_frame.h"
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
@@ skipping 607 matching lines @@
   node->finalizer()->AcceptStatementVisitor(this);
   --depth_.catch_;
 }
 
 
 void ScopeBuilder::VisitFunctionNode(FunctionNode* node) {
   List<TypeParameter>& type_parameters = node->type_parameters();
   for (intptr_t i = 0; i < type_parameters.length(); ++i) {
     VisitTypeParameter(type_parameters[i]);
   }
+
+  if (node->async_marker() == FunctionNode::kSyncYielding) {
+    LocalScope* scope = parsed_function_->node_sequence()->scope();
+    for (intptr_t i = 0;
+         i < parsed_function_->function().NumOptionalPositionalParameters();
+         i++) {
+      scope->VariableAt(i)->set_is_forced_stack();
+    }
+  }
+
   // Do not visit the positional and named parameters, because they've
   // already been added to the scope.
   if (node->body() != NULL) {
     node->body()->AcceptStatementVisitor(this);
   }
 
   // Ensure that :await_jump_var and :await_ctx_var are captured.
   if (node->async_marker() == FunctionNode::kSyncYielding) {
     {
       LocalVariable* temp = NULL;
@@ skipping 440 matching lines @@
   Library* kernel_library = Library::Cast(kernel_klass->parent());
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
+dart::RawUnresolvedClass* TranslationHelper::ToUnresolvedClass(
+    Class* kernel_klass) {
+  dart::RawClass* klass = NULL;
+
+  const dart::String& class_name = DartClassName(kernel_klass);
+  Library* kernel_library = Library::Cast(kernel_klass->parent());
+  dart::Library& library =
+      dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
+
+  ASSERT(klass != Object::null());
+  return dart::UnresolvedClass::New(library, class_name,
+                                    TokenPosition::kNoSource);
+}
+
+
 dart::RawField* TranslationHelper::LookupFieldByKernelField(
     Field* kernel_field) {
   TreeNode* node = kernel_field->parent();
 
   dart::Class& klass = dart::Class::Handle(Z);
   if (node->IsClass()) {
     klass = LookupClassByKernelClass(Class::Cast(node));
   } else {
     ASSERT(node->IsLibrary());
     dart::Library& library = dart::Library::Handle(
@@ skipping 714 matching lines @@
       stack_(NULL),
       pending_argument_count_(0),
       graph_entry_(NULL),
       scopes_(NULL),
       breakable_block_(NULL),
       switch_block_(NULL),
       try_finally_block_(NULL),
       try_catch_block_(NULL),
       next_used_try_index_(0),
       catch_block_(NULL),
-      type_translator_(&translation_helper_, &active_class_),
+      type_translator_(&translation_helper_,
+                       &active_class_,
+                       /* finalize= */ true),
       constant_evaluator_(this,
                           zone_,
                           &translation_helper_,
                           &type_translator_) {}
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {}
 
 
 Fragment FlowGraphBuilder::TranslateFinallyFinalizers(
@@ skipping 1981 matching lines @@
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return dart::AbstractType::ZoneHandle(Z, result_.raw());
 }
 
 
 AbstractType& DartTypeTranslator::TranslateTypeWithoutFinalization(
     DartType* node) {
   bool saved_finalize = finalize_;
   finalize_ = false;
-  H.SetFinalize(false);
   AbstractType& result = TranslateType(node);
   finalize_ = saved_finalize;
-  H.SetFinalize(saved_finalize);
   return result;
 }
 
 
 const AbstractType& DartTypeTranslator::TranslateVariableType(
     VariableDeclaration* variable) {
   AbstractType& abstract_type = TranslateType(variable->type());
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
@@ skipping 135 matching lines @@
 }
 
 
 void DartTypeTranslator::VisitInterfaceType(InterfaceType* node) {
   // NOTE: That an interface type like `T<A, B>` is considered to be
   // malformed iff `T` is malformed.
   //   => We therefore ignore errors in `A` or `B`.
   const TypeArguments& type_arguments = TranslateTypeArguments(
       node->type_arguments().raw_array(), node->type_arguments().length());
 
-  const dart::Class& klass =
-      dart::Class::Handle(Z, H.LookupClassByKernelClass(node->klass()));
 
+  dart::Object& klass =
+      dart::Object::Handle(Z, H.ToUnresolvedClass(node->klass()));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
-  result_.SetIsResolved();
   if (finalize_) {
-    result_ = ClassFinalizer::FinalizeType(klass, result_,
+    ASSERT(active_class_->klass != NULL);
+    result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_,
                                            ClassFinalizer::kCanonicalize);
   }
 }
 
 
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
 }
 
 
@@ skipping 1606 matching lines @@
     //     ...
     //   }
     //
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     LocalVariable* exception_var = scope->VariableAt(2);
     LocalVariable* stack_trace_var = scope->VariableAt(3);
     ASSERT(exception_var->name().raw() == Symbols::ExceptionParameter().raw());
     ASSERT(stack_trace_var->name().raw() ==
            Symbols::StackTraceParameter().raw());
 
-    exception_var->set_is_forced_stack();
-    stack_trace_var->set_is_forced_stack();
-
     TargetEntryInstr* no_error;
     TargetEntryInstr* error;
 
     continuation += LoadLocal(exception_var);
     continuation += BranchIfNull(&no_error, &error);
 
     Fragment rethrow(error);
     rethrow += LoadLocal(exception_var);
     rethrow += PushArgument();
     rethrow += LoadLocal(stack_trace_var);
@@ skipping 69 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)