Sane asynchronous debugging and stack traces

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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/ast_transformer.h"
 
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/thread.h"
 
@@ skipping 111 matching lines @@
   result_ = new (Z) TypeNode(node->token_pos(), node->type());
 }
 
 
 void AwaitTransformer::VisitAwaitNode(AwaitNode* node) {
   // Await transformation:
   //
   //   :await_temp_var_X = <expr>;
   //   AwaitMarker(kNewContinuationState);
   //   :result_param = _awaitHelper(
-  //      :await_temp_var_X, :async_then_callback, :async_catch_error_callback);
+  //      :await_temp_var_X,
+  //      :async_then_callback,
+  //      :async_catch_error_callback,
+  //      :async_op);
   //   return;  // (return_type() == kContinuationTarget)
   //
   //   :saved_try_ctx_var = :await_saved_try_ctx_var_y;
   //   :await_temp_var_(X+1) = :result_param;
 
   const TokenPosition token_pos = ST(node->token_pos());
   LocalVariable* async_op =
       GetVariableInScope(preamble_->scope(), Symbols::AsyncOperation());
   LocalVariable* async_then_callback =
       GetVariableInScope(preamble_->scope(), Symbols::AsyncThenCallback());
   LocalVariable* async_catch_error_callback = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncCatchErrorCallback());
   LocalVariable* result_param =
       GetVariableInScope(preamble_->scope(), Symbols::AsyncOperationParam());
   LocalVariable* error_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationErrorParam());
   LocalVariable* stack_trace_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationStackTraceParam());
 
   AstNode* transformed_expr = Transform(node->expr());
   LocalVariable* await_temp =
       AddNewTempVarToPreamble(transformed_expr, ST(node->token_pos()));
 
   AwaitMarkerNode* await_marker =
       new (Z) AwaitMarkerNode(async_temp_scope_, node->scope(), token_pos);
   preamble_->Add(await_marker);
 
   // :result_param = _awaitHelper(
-  //      :await_temp, :async_then_callback, :async_catch_error_callback)
+  //      :await_temp,
+  //      :async_then_callback,
+  //      :async_catch_error_callback,
+  //      :async_op)
   const Library& async_lib = Library::Handle(Library::AsyncLibrary());
   const Function& async_await_helper = Function::ZoneHandle(
       Z, async_lib.LookupFunctionAllowPrivate(Symbols::AsyncAwaitHelper()));
   ASSERT(!async_await_helper.IsNull());
   ArgumentListNode* async_await_helper_args =
       new (Z) ArgumentListNode(token_pos);
   async_await_helper_args->Add(new (Z) LoadLocalNode(token_pos, await_temp));
   async_await_helper_args->Add(
       new (Z) LoadLocalNode(token_pos, async_then_callback));
   async_await_helper_args->Add(
       new (Z) LoadLocalNode(token_pos, async_catch_error_callback));
+  async_await_helper_args->Add(new (Z) LoadLocalNode(token_pos, async_op));
   StaticCallNode* await_helper_call = new (Z) StaticCallNode(
       node->token_pos(), async_await_helper, async_await_helper_args);
 
   preamble_->Add(
       new (Z) StoreLocalNode(token_pos, result_param, await_helper_call));
 
   ReturnNode* continuation_return = new (Z) ReturnNode(token_pos);
   continuation_return->set_return_type(ReturnNode::kContinuationTarget);
   preamble_->Add(continuation_return);
 
@@ skipping 324 matching lines @@
 }
 
 
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   AstNode* new_exception = Transform(node->exception());
   result_ = MakeName(
       new (Z) ThrowNode(node->token_pos(), new_exception, node->stacktrace()));
 }
 
 }  // namespace dart