Fix another missing source location VM stacktrace with async code.

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 118 matching lines @@
       preamble_->scope(), Symbols::AsyncOperation());
   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());
   preamble_->Add(new(Z) StoreLocalNode(
-      Scanner::kNoSourcePos, result_param, transformed_expr));
+      node->token_pos(), result_param, transformed_expr));
 
   LoadLocalNode* load_result_param = new(Z) LoadLocalNode(
-      Scanner::kNoSourcePos, result_param);
+      node->token_pos(), result_param);
 
   const Class& future_cls =
       Class::ZoneHandle(Z, thread()->isolate()->object_store()->future_class());
   ASSERT(!future_cls.IsNull());
   const AbstractType& future_type =
       AbstractType::ZoneHandle(Z, future_cls.RareType());
   ASSERT(!future_type.IsNull());
 
   LocalScope* is_not_future_scope = ChainNewScope(preamble_->scope());
   SequenceNode* is_not_future_branch =
-      new (Z) SequenceNode(Scanner::kNoSourcePos, is_not_future_scope);
+      new (Z) SequenceNode(node->token_pos(), is_not_future_scope);

[hausner, 2015/02/12 17:18:44]

The reason why all these nodes that have no equivalent source code position are
marked with kNoSourcePos is so that the debugger does not set breakpoints at
meaningless locations, and does not stop there when stepping. 

 
   // if (:result_param is !Future) {
   //   :result_param = Future.value(:result_param);
   // }
   const Function& value_ctor = Function::ZoneHandle(
       Z, future_cls.LookupFunction(Symbols::FutureValue()));
   ASSERT(!value_ctor.IsNull());
-  ArgumentListNode* ctor_args = new (Z) ArgumentListNode(Scanner::kNoSourcePos);
-  ctor_args->Add(new (Z) LoadLocalNode(Scanner::kNoSourcePos, result_param));
+  ArgumentListNode* ctor_args = new (Z) ArgumentListNode(node->token_pos());
+  ctor_args->Add(new (Z) LoadLocalNode(node->token_pos(), result_param));
   ConstructorCallNode* ctor_call =
-      new (Z) ConstructorCallNode(Scanner::kNoSourcePos,
+      new (Z) ConstructorCallNode(node->token_pos(),
                                   TypeArguments::ZoneHandle(Z),
                                   value_ctor,
                                   ctor_args);
   is_not_future_branch->Add(new (Z) StoreLocalNode(
-      Scanner::kNoSourcePos, result_param, ctor_call));
+      node->token_pos(), result_param, ctor_call));
   AstNode* is_not_future_test = new (Z) ComparisonNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       Token::kISNOT,
       load_result_param,
-      new (Z) TypeNode(Scanner::kNoSourcePos, future_type));
-  preamble_->Add(new(Z) IfNode(Scanner::kNoSourcePos,
+      new (Z) TypeNode(node->token_pos(), future_type));
+  preamble_->Add(new(Z) IfNode(node->token_pos(),
                                is_not_future_test,
                                is_not_future_branch,
                                NULL));
 
   AwaitMarkerNode* await_marker = new (Z) AwaitMarkerNode();
   await_marker->set_scope(preamble_->scope());
   preamble_->Add(await_marker);
-  ArgumentListNode* args = new(Z) ArgumentListNode(Scanner::kNoSourcePos);
+  ArgumentListNode* args = new(Z) ArgumentListNode(node->token_pos());
 
-  args->Add(new(Z) LoadLocalNode(Scanner::kNoSourcePos, async_op));
+  args->Add(new(Z) LoadLocalNode(node->token_pos(), async_op));
   preamble_->Add(new (Z) StoreLocalNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       result_param,
-      new(Z) InstanceCallNode(Scanner::kNoSourcePos,
+      new(Z) InstanceCallNode(node->token_pos(),

[Florian Schneider, 2015/02/13 10:25:27]

To fix the bug it would be enough to record it here, and I _think_ that the
await node's token position should be recorded somewhere anyway.

                               load_result_param,
                               Symbols::FutureThen(),
                               args)));
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Function& async_catch_helper = Function::ZoneHandle(
       Z, core_lib.LookupFunctionAllowPrivate(Symbols::AsyncCatchHelper()));
   ASSERT(!async_catch_helper.IsNull());
   ArgumentListNode* catch_helper_args = new (Z) ArgumentListNode(
-      Scanner::kNoSourcePos);
+      node->token_pos());
   InstanceGetterNode* catch_error_getter = new (Z) InstanceGetterNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       load_result_param,
       Symbols::FutureCatchError());
   catch_helper_args->Add(catch_error_getter);
   catch_helper_args->Add(new (Z) LoadLocalNode(
-      Scanner::kNoSourcePos, async_op));
+      node->token_pos(), async_op));
   preamble_->Add(new (Z) StaticCallNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       async_catch_helper,
       catch_helper_args));
-  ReturnNode* continuation_return = new(Z) ReturnNode(Scanner::kNoSourcePos);
+  ReturnNode* continuation_return = new(Z) ReturnNode(node->token_pos());
   continuation_return->set_return_type(ReturnNode::kContinuationTarget);
   preamble_->Add(continuation_return);
 
   // If this expression is part of a try block, also append the code for
   // restoring the saved try context that lives on the stack.
   const String& async_saved_try_ctx_name =
       String::Handle(Z, parsed_function_.async_saved_try_ctx_name());
   if (!async_saved_try_ctx_name.IsNull()) {
     LocalVariable* async_saved_try_ctx =
         GetVariableInScope(preamble_->scope(), async_saved_try_ctx_name);
     preamble_->Add(new (Z) StoreLocalNode(
-        Scanner::kNoSourcePos,
+        node->token_pos(),
         parsed_function_.saved_try_ctx(),
-        new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
+        new (Z) LoadLocalNode(node->token_pos(), async_saved_try_ctx)));
   }
 
   LoadLocalNode* load_error_param = new (Z) LoadLocalNode(
-      Scanner::kNoSourcePos, error_param);
+      node->token_pos(), error_param);
   LoadLocalNode* load_stack_trace_param = new (Z) LoadLocalNode(
-      Scanner::kNoSourcePos, stack_trace_param);
+      node->token_pos(), stack_trace_param);
   SequenceNode* error_ne_null_branch = new (Z) SequenceNode(
-      Scanner::kNoSourcePos, ChainNewScope(preamble_->scope()));
+      node->token_pos(), ChainNewScope(preamble_->scope()));
   error_ne_null_branch->Add(new (Z) ThrowNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       load_error_param,
       load_stack_trace_param));
   preamble_->Add(new (Z) IfNode(
-      Scanner::kNoSourcePos,
+      node->token_pos(),
       new (Z) ComparisonNode(
-          Scanner::kNoSourcePos,
+          node->token_pos(),
           Token::kNE,
           load_error_param,
-          new (Z) LiteralNode(Scanner::kNoSourcePos,
+          new (Z) LiteralNode(node->token_pos(),
                               Object::null_instance())),
           error_ne_null_branch,
           NULL));
 
   LocalVariable* result = AddToPreambleNewTempVar(new(Z) LoadLocalNode(
-      Scanner::kNoSourcePos, result_param));
-  result_ = new(Z) LoadLocalNode(Scanner::kNoSourcePos, result);
+      node->token_pos(), result_param));

[hausner, 2015/02/12 17:18:44]

This is a good example of code that will most likely have a very low compiled
code address. When the user attempts to set a breakpoint in the line that
contains node->token_pos(), this may be the place the debugger stops instead of
stopping at a place that reflects user-visible code.

[Florian Schneider, 2015/02/13 10:21:06]

I can only assign the tokenposition to the call instructions here if that helps.
Unfortunately we don't have any tests that would catch any regression in
debugger experience for async code.

+  result_ = new(Z) LoadLocalNode(node->token_pos(), result);
 }
 
 
 // Transforms boolean expressions into a sequence of evaluatons that only lazily
 // evaluate subexpressions.
 //
 // Example:
 //
 //   (a || b) only evaluates b if a is false
 //
@@ skipping 338 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(Z) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart