Propagate the stack trace of the inner-most throw when using async/await.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 1466 matching lines @@
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name,
                                       deopt_id);
 }
 
 
 void EffectGraphVisitor::BuildAwaitJump(LocalVariable* old_context,
                                         LocalVariable* continuation_result,
                                         LocalVariable* continuation_error,
+                                        LocalVariable* continuation_stack_trace,
                                         const intptr_t old_ctx_level,
                                         JoinEntryInstr* target) {
   // Building a jump consists of the following actions:
   // * Record the current continuation result in a temporary.
   // * Restore the old context.
   // * Overwrite the old context's continuation result with the temporary.
   // * Append a Goto to the target's join.
   ASSERT((continuation_result != NULL) && continuation_result->is_captured());
   ASSERT((continuation_error != NULL) && continuation_error->is_captured());
   ASSERT((old_context != NULL) && old_context->is_captured());
   // Before restoring the continuation context we need to temporary save the
   // result and error parameter.
   LocalVariable* temp_result_var = EnterTempLocalScope(
       Bind(BuildLoadLocal(*continuation_result)));
   LocalVariable* temp_error_var = EnterTempLocalScope(
       Bind(BuildLoadLocal(*continuation_error)));
+  LocalVariable* temp_stack_trace_var = EnterTempLocalScope(
+      Bind(BuildLoadLocal(*continuation_stack_trace)));
   // Restore the saved continuation context.
   BuildRestoreContext(*old_context);
 
   // Pass over the continuation result.
 
   // FlowGraphBuilder is at top context level, but the await target has possibly
   // been recorded in a nested context (old_ctx_level). We need to unroll
   // manually here.
   intptr_t delta = old_ctx_level -
                    continuation_result->owner()->context_level();
@@ skipping 18 matching lines @@
   context_val = Bind(new(I) LoadLocalInstr(*temp_context_var));
   store_val = Bind(new(I) LoadLocalInstr(*temp_error_var));
   StoreInstanceFieldInstr* store2 = new(I) StoreInstanceFieldInstr(
       Context::variable_offset(continuation_error->index()),
       context_val,
       store_val,
       kEmitStoreBarrier,
       Scanner::kNoSourcePos);
   Do(store2);
 
+  context_val = Bind(new(I) LoadLocalInstr(*temp_context_var));
+  store_val = Bind(new(I) LoadLocalInstr(*temp_stack_trace_var));
+  StoreInstanceFieldInstr* store3 = new(I) StoreInstanceFieldInstr(
+      Context::variable_offset(continuation_stack_trace->index()),
+      context_val,
+      store_val,
+      kEmitStoreBarrier,
+      Scanner::kNoSourcePos);
+  Do(store3);
+
   Do(ExitTempLocalScope(temp_context_var));
+  Do(ExitTempLocalScope(temp_stack_trace_var));
   Do(ExitTempLocalScope(temp_error_var));
   Do(ExitTempLocalScope(temp_result_var));
 
   // Goto saved join.
   Goto(target);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
@@ skipping 2342 matching lines @@
     LoadLocalNode* load_jump_count = new(I) LoadLocalNode(
         Scanner::kNoSourcePos, jump_var);
     ComparisonNode* check_jump_count;
     const intptr_t num_await_states = owner()->await_joins()->length();
     LocalVariable* old_context = top_scope->LookupVariable(
         Symbols::AwaitContextVar(), false);
     LocalVariable* continuation_result = top_scope->LookupVariable(
         Symbols::AsyncOperationParam(), false);
     LocalVariable* continuation_error = top_scope->LookupVariable(
         Symbols::AsyncOperationErrorParam(), false);
+    LocalVariable* continuation_stack_trace = top_scope->LookupVariable(
+        Symbols::AsyncOperationStackTraceParam(), false);
     for (intptr_t i = 0; i < num_await_states; i++) {
       check_jump_count = new(I) ComparisonNode(
           Scanner::kNoSourcePos,
           Token::kEQ,
           load_jump_count,
           new(I) LiteralNode(
               Scanner::kNoSourcePos, Smi::ZoneHandle(I, Smi::New(i))));
       TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
       check_jump_count->Visit(&for_test);
       EffectGraphVisitor for_true(owner());
       EffectGraphVisitor for_false(owner());
 
       for_true.BuildAwaitJump(old_context,
                               continuation_result,
                               continuation_error,
+                              continuation_stack_trace,
                               (*owner()->await_levels())[i],
                               (*owner()->await_joins())[i]);
       Join(for_test, for_true, for_false);
 
       if (i == 0) {
         // Manually link up the preamble start.
         preamble_start->previous()->set_next(for_test.entry());
         for_test.entry()->set_previous(preamble_start->previous());
       }
       if (i == (num_await_states - 1)) {
@@ skipping 382 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart