VM: Fix source location in stack trace of async code.

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 5927 matching lines @@
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
       new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   completer_args->Add(
       new (Z) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
   completer_args->Add(
       new (Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var));
   current_block_->statements->Add(new (Z) InstanceCallNode(
-      Scanner::kNoSourcePos,
+      TokenPos(),
       new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_completer),
       Symbols::CompleterCompleteError(),
       completer_args));
   ReturnNode* return_node = new (Z) ReturnNode(Scanner::kNoSourcePos);
   // 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();
@@ skipping 268 matching lines @@
       Symbols::AsyncOperation(), false);
   ClosureNode* cn = new(Z) ClosureNode(
       Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_op_var,
       cn);
   current_block_->statements->Add(store_async_op);
 
   // Add to AST:
-  //   new Future(:async_op);
+  //   new Future.microtask(:async_op);
   ArgumentListNode* arguments = new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   arguments->Add(new (Z) LoadLocalNode(
       Scanner::kNoSourcePos, async_op_var));
   ConstructorCallNode* future_node = new (Z) ConstructorCallNode(
       Scanner::kNoSourcePos, TypeArguments::ZoneHandle(Z), constructor,
       arguments);
   current_block_->statements->Add(future_node);
 
   // Add to AST:
   //   return :async_completer.future;
@@ skipping 3161 matching lines @@
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
   if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
     ConsumeToken();
     parsed_function()->record_await();
-    expr = new (Z) AwaitNode(TokenPos(), ParseUnaryExpr());
+    expr = new (Z) AwaitNode(op_pos, ParseUnaryExpr());
   } else if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     if (unary_op == Token::kSUB) {
       unary_op = Token::kNEGATE;
     }
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (expr->IsPrimaryNode() && (expr->AsPrimaryNode()->IsSuper())) {
       expr = BuildUnarySuperOperator(unary_op, expr->AsPrimaryNode());
     } else {
@@ skipping 2812 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart