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"
 
@@ skipping 581 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 437 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 677 matching lines @@
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(function, arguments, args_descriptor));
   if (result.IsError()) {
     H.ReportError(Error::Cast(result), "error evaluating constant constructor");
   }
   return result;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
-    TreeNode* node, ParsedFunction* parsed_function,
+    TreeNode* node,
+    ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
-    InlineExitCollector* exit_collector, intptr_t osr_id,
+    InlineExitCollector* exit_collector,
+    intptr_t osr_id,
     intptr_t first_block_id)
     : zone_(Thread::Current()->zone()),
-      translation_helper_(Thread::Current(), zone_,
+      translation_helper_(Thread::Current(),
+                          zone_,
                           Thread::Current()->isolate()),
       node_(node),
       parsed_function_(parsed_function),
       osr_id_(osr_id),
       ic_data_array_(ic_data_array),
       exit_collector_(exit_collector),
       next_block_id_(first_block_id),
       next_function_id_(0),
       context_depth_(0),
       loop_depth_(0),
       try_depth_(0),
       catch_depth_(0),
       for_in_depth_(0),
       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_),
-      constant_evaluator_(this, zone_, &translation_helper_,
+      type_translator_(&translation_helper_,
+                       &active_class_,
+                       /* finalize= */ true),
+      constant_evaluator_(this,
+                          zone_,
+                          &translation_helper_,
                           &type_translator_) {}
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {}
 
 
 Fragment FlowGraphBuilder::TranslateFinallyFinalizers(
     TryFinallyBlock* outer_finally, intptr_t target_context_depth) {
   TryFinallyBlock* const saved_block = try_finally_block_;
   const intptr_t saved_depth = context_depth_;
@@ skipping 1992 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;
 }
 
 
 void DartTypeTranslator::VisitInvalidType(InvalidType* node) {
   result_ = ClassFinalizer::NewFinalizedMalformedType(
       Error::Handle(Z),  // No previous error.
       dart::Script::Handle(Z, dart::Script::null()), TokenPosition::kNoSource,
       "[InvalidType] in Kernel IR.");
 }
@@ skipping 117 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);
+
+  if (finalize_) {
+    klass = H.LookupClassByKernelClass(node->klass());
+  } else {
+    klass = H.ToUnresolvedClass(node->klass());
+  }
+
 
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
-  result_.SetIsResolved();
   if (finalize_) {
-    result_ = ClassFinalizer::FinalizeType(klass, result_,
+    result_.SetIsResolved();
+    result_ = ClassFinalizer::FinalizeType(dart::Class::Cast(klass), result_,
                                            ClassFinalizer::kCanonicalize);
   }
 }
 
 
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
 }
 
 
@@ skipping 1604 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