Run async immediately in dart2js and VM.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 7496 matching lines @@
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncStackTraceVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
 
-  // Create and return a new future that executes a closure with the current
-  // body.
+  // Create and return a new _AsyncAwaitCompleter that executes a closure with
+  // the current body.
 
   // No need to capture parameters or other variables, since they have already
   // been captured in the corresponding scope as the body has been parsed within
   // a nested block (contained in the async function's block).
-  const Class& future = Class::ZoneHandle(Z, I->object_store()->future_class());
-  ASSERT(!future.IsNull());
-  const Function& constructor = Function::ZoneHandle(
-      Z, future.LookupFunction(Symbols::FutureMicrotask()));
-  ASSERT(!constructor.IsNull());
-  const Class& completer =
-      Class::ZoneHandle(Z, I->object_store()->completer_class());
-  ASSERT(!completer.IsNull());
-  const Function& completer_constructor = Function::ZoneHandle(
-      Z, completer.LookupFunction(Symbols::CompleterSyncConstructor()));
+
+  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
+
+  const Class& completer_class = Class::Handle(
+      Z, async_lib.LookupClassAllowPrivate(Symbols::_AsyncAwaitCompleter()));
+  ASSERT(!completer_class.IsNull());
+  const Function& completer_constructor =
+      Function::ZoneHandle(Z, completer_class.LookupConstructorAllowPrivate(
+                                  Symbols::_AsyncAwaitCompleterConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
   LocalVariable* async_completer =
       current_block_->scope->LookupVariable(Symbols::AsyncCompleter(), false);
 
   const TokenPosition token_pos = ST(closure_body->token_pos());
   // Add to AST:
   //   :async_completer = new Completer.sync();
   ArgumentListNode* empty_args = new (Z) ArgumentListNode(token_pos);
   ConstructorCallNode* completer_constructor_node =
@@ skipping 14 matching lines @@
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var =
       current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
   ClosureNode* cn =
       new (Z) ClosureNode(token_pos, closure, NULL, closure_body->scope());
   StoreLocalNode* store_async_op =
       new (Z) StoreLocalNode(token_pos, async_op_var, cn);
   current_block_->statements->Add(store_async_op);
 
-  const Library& async_lib = Library::Handle(Library::AsyncLibrary());
-
   if (FLAG_causal_async_stacks) {
     // Add to AST:
     //   :async_stack_trace = _asyncStackTraceHelper();
     const Function& async_stack_trace_helper = Function::ZoneHandle(
         Z,
         async_lib.LookupFunctionAllowPrivate(Symbols::AsyncStackTraceHelper()));
     ASSERT(!async_stack_trace_helper.IsNull());
     ArgumentListNode* async_stack_trace_helper_args =
         new (Z) ArgumentListNode(token_pos);
     async_stack_trace_helper_args->Add(
@@ skipping 41 matching lines @@
       token_pos, async_error_wrapper_helper, async_error_wrapper_helper_args);
   LocalVariable* async_catch_error_callback_var =
       current_block_->scope->LookupVariable(Symbols::AsyncCatchErrorCallback(),
                                             false);
   StoreLocalNode* store_async_catch_error_callback = new (Z) StoreLocalNode(
       token_pos, async_catch_error_callback_var, error_wrapper_call);
 
   current_block_->statements->Add(store_async_catch_error_callback);
 
   // Add to AST:
-  //   new Future.microtask(:async_op);
+  //   :async_completer.start(:async_op);
   ArgumentListNode* arguments = new (Z) ArgumentListNode(token_pos);
   arguments->Add(new (Z) LoadLocalNode(token_pos, async_op_var));
-  ConstructorCallNode* future_node = new (Z) ConstructorCallNode(
-      token_pos, TypeArguments::ZoneHandle(Z), constructor, arguments);
-  current_block_->statements->Add(future_node);
+  InstanceCallNode* start_call = new (Z) InstanceCallNode(
+      token_pos, new (Z) LoadLocalNode(token_pos, async_completer),
+      Symbols::_AsyncAwaitStart(), arguments);
+  current_block_->statements->Add(start_call);
 
   // Add to AST:
   //   return :async_completer.future;
   ReturnNode* return_node = new (Z) ReturnNode(
       token_pos,
       new (Z) InstanceGetterNode(
           token_pos, new (Z) LoadLocalNode(token_pos, async_completer),
           Symbols::CompleterFuture()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
@@ skipping 7460 matching lines @@
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME