Fix a couple of bugs with async stack traces

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 6619 matching lines @@
       current_block_->scope->LookupVariable(Symbols::ColonController(), false);
   ASSERT(controller != NULL);
   ArgumentListNode* args = new (Z) ArgumentListNode(TokenPosition::kNoSource);
   args->Add(new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, exception_param.var));
   args->Add(new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, stack_trace_param.var));
   current_block_->statements->Add(new (Z) InstanceCallNode(
       try_end_pos, new (Z) LoadLocalNode(TokenPosition::kNoSource, controller),
       Symbols::AddError(), args));
-  ReturnNode* return_node = new (Z) ReturnNode(TokenPosition::kNoSource);
+  ReturnNode* return_node = new (Z) ReturnNode(try_end_pos);
   AddNodeForFinallyInlining(return_node);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   TryStack* try_statement = PopTry();
   ASSERT(try_stack_ == NULL);  // We popped the outermost try block.
 
   // Finally block: closing the stream and returning. Instead of simply
@@ skipping 129 matching lines @@
   ArgumentListNode* completer_args =
       new (Z) ArgumentListNode(TokenPosition::kNoSource);
   completer_args->Add(
       new (Z) LoadLocalNode(TokenPosition::kNoSource, exception_param.var));
   completer_args->Add(
       new (Z) LoadLocalNode(TokenPosition::kNoSource, stack_trace_param.var));
   current_block_->statements->Add(new (Z) InstanceCallNode(
       func_end_pos,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, async_completer),
       Symbols::CompleterCompleteError(), completer_args));
-  ReturnNode* return_node = new (Z) ReturnNode(TokenPosition::kNoSource);
+  ReturnNode* return_node = new (Z) ReturnNode(func_end_pos);
   // Behavior like a continuation return, i.e,. don't call a completer.
   return_node->set_return_type(ReturnNode::kContinuation);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   handler_types.SetLength(0);
@@ skipping 2557 matching lines @@
     if (outer_saved_try_ctx != NULL) {
       current_block_->statements->Add(new (Z) StoreLocalNode(
           TokenPosition::kNoSource, outer_saved_try_ctx,
           new (Z) LoadLocalNode(TokenPosition::kNoSource,
                                 outer_async_saved_try_ctx)));
     }
     // :for-in-iter.cancel();
     ArgumentListNode* no_args =
         new (Z) ArgumentListNode(TokenPosition::kNoSource);
     current_block_->statements->Add(new (Z) InstanceCallNode(
-        TokenPosition::kNoSource,
+        ST(await_for_pos),
         new (Z) LoadLocalNode(TokenPosition::kNoSource, iterator_var),
         Symbols::Cancel(), no_args));
     finally_clause = CloseBlock();
 
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
           new (Z) InlinedFinallyNode(TokenPosition::kNoSource, finally_clause,
                                      context_var, outer_try_index);
       finally_clause = NULL;
@@ skipping 5828 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME