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

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3053 matching lines @@
          func.IsGetterFunction() ||
          func.is_async_closure());
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
   } else if (func.is_async_closure()) {
     // Async closures have two optional parameters:
     // * A continuation result.
     // * A continuation error.

[hausner, 2015/02/04 16:47:33]

Comment is now out of sync with the code. 

     //
     // If the error!=null we rethrow the error at the next await.
     const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
     ParamDesc result_param;
     result_param.name = &Symbols::AsyncOperationParam();
     result_param.default_value = &Object::null_instance();
     result_param.type = &dynamic_type;
     ParamDesc error_param;
     error_param.name = &Symbols::AsyncOperationErrorParam();
     error_param.default_value = &Object::null_instance();
     error_param.type = &dynamic_type;
+    ParamDesc stack_trace_param;
+    stack_trace_param.name = &Symbols::AsyncOperationStackTraceParam();
+    stack_trace_param.default_value = &Object::null_instance();
+    stack_trace_param.type = &dynamic_type;
     params.parameters->Add(result_param);
     params.parameters->Add(error_param);
-    params.num_optional_parameters += 2;
+    params.parameters->Add(stack_trace_param);
+    params.num_optional_parameters += 3;
     params.has_optional_positional_parameters = true;
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Parse and discard any formal parameters. They are accessed as
       // context variables.
       ParamList parse_away;
       ParseFormalParameterList(allow_explicit_default_values,
@@ skipping 2962 matching lines @@
   ParamDesc result_param;
   result_param.name = &Symbols::AsyncOperationParam();
   result_param.default_value = &Object::null_instance();
   result_param.type = &dynamic_type;
   closure_params.parameters->Add(result_param);
   ParamDesc error_param;
   error_param.name = &Symbols::AsyncOperationErrorParam();
   error_param.default_value = &Object::null_instance();
   error_param.type = &dynamic_type;
   closure_params.parameters->Add(error_param);
+  ParamDesc stack_trace_param;
+  stack_trace_param.name = &Symbols::AsyncOperationStackTraceParam();
+  stack_trace_param.default_value = &Object::null_instance();
+  stack_trace_param.type = &dynamic_type;
+  closure_params.parameters->Add(stack_trace_param);
   closure_params.has_optional_positional_parameters = true;
-  closure_params.num_optional_parameters += 2;
+  closure_params.num_optional_parameters += 3;
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Create and set the signature class of the closure.
     const String& sig = String::Handle(Z, closure.Signature());
     Class& sig_cls = Class::Handle(Z, library_.LookupLocalClass(sig));
     if (sig_cls.IsNull()) {
       sig_cls =
@@ skipping 6149 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart