TokenPositions on more nodes when running from Kernel

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 40 matching lines @@
     } else if ((*outermost_node)->IsConstructor()) {
       parent = Constructor::Cast(*outermost_node)->parent();
     } else if ((*outermost_node)->IsField()) {
       parent = Field::Cast(*outermost_node)->parent();
     }
     if (parent != NULL && parent->IsClass()) *klass = Class::Cast(parent);
   }
 }
 
 
-void ScopeBuilder::EnterScope(TreeNode* node) {
+void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
+  scope_->set_begin_token_pos(start_position);
   result_->scopes.Insert(node, scope_);
 }
 
 
-void ScopeBuilder::ExitScope() {
+void ScopeBuilder::ExitScope(TokenPosition end_position) {
+  scope_->set_end_token_pos(end_position);
   scope_ = scope_->parent();
 }
 
 
-LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name,
+LocalVariable* ScopeBuilder::MakeVariable(TokenPosition declaration_pos,
+                                          TokenPosition token_pos,
+                                          const dart::String& name,
                                           const AbstractType& type) {
-  return new (Z) LocalVariable(TokenPosition::kNoSource,
-                               TokenPosition::kNoSource, name, type);
+  return new (Z) LocalVariable(declaration_pos, token_pos, name, type);
 }
 
 
 void ScopeBuilder::AddParameters(FunctionNode* function, intptr_t pos) {
   List<VariableDeclaration>& positional = function->positional_parameters();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     AddParameter(positional[i], pos++);
   }
   List<VariableDeclaration>& named = function->named_parameters();
   for (intptr_t i = 0; i < named.length(); ++i) {
     AddParameter(named[i], pos++);
   }
 }
 
 
 void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
                                 intptr_t pos) {
-  LocalVariable* variable = MakeVariable(H.DartSymbol(declaration->name()),
-                                         T.TranslateVariableType(declaration));
+  LocalVariable* variable = MakeVariable(
+      declaration->position(), declaration->position(),

[jensj, 2017/01/13 10:14:44]

This is different than before --- I haven't looked into what the right thing is,
I will fix it later if it turns out this is wrong.

+      H.DartSymbol(declaration->name()), T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->InsertParameterAt(pos, variable);
   result_->locals.Insert(declaration, variable);
 
   // The default value may contain 'let' bindings for which the constant
   // evaluator needs scope bindings.
   Expression* defaultValue = declaration->initializer();
   if (defaultValue != NULL) {
@@ skipping 26 matching lines @@
   }
 
   // No need to create variables for try/catch-statements inside
   // nested functions.
   if (depth_.function_ > 0) return;
   if (variables->length() >= nesting_depth) return;
 
   // If variable was not lifted by the transformer introduce a new
   // one into the current function scope.
   if (v == NULL) {
-    v = MakeVariable(GenerateName(prefix, nesting_depth - 1),
+    v = MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                     GenerateName(prefix, nesting_depth - 1),
                      AbstractType::dynamic_type());
 
     // If transformer did not lift the variable then there is no need
     // to lift it into the context when we encouter a YieldStatement.
     v->set_is_forced_stack();
     current_function_scope_->AddVariable(v);
   }
 
   variables->Add(v);
 }
@@ skipping 12 matching lines @@
                        depth_.catch_);
 }
 
 
 void ScopeBuilder::AddIteratorVariable() {
   if (depth_.function_ > 0) return;
   if (result_->iterator_variables.length() >= depth_.for_in_) return;
 
   ASSERT(result_->iterator_variables.length() == depth_.for_in_ - 1);
   LocalVariable* iterator =
-      MakeVariable(GenerateName(":iterator", depth_.for_in_ - 1),
+      MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                   GenerateName(":iterator", depth_.for_in_ - 1),
                    AbstractType::dynamic_type());
   current_function_scope_->AddVariable(iterator);
   result_->iterator_variables.Add(iterator);
 }
 
 
 void ScopeBuilder::LookupVariable(VariableDeclaration* declaration) {
   LocalVariable* variable = result_->locals.Lookup(declaration);
   if (variable == NULL) {
     // We have not seen a declaration of the variable, so it must be the
@@ skipping 45 matching lines @@
 
 
 void ScopeBuilder::AddVariable(VariableDeclaration* declaration) {
   // In case `declaration->IsConst()` the flow graph building will take care of
   // evaluating the constant and setting it via
   // `declaration->SetConstantValue()`.
   const dart::String& name = declaration->name()->is_empty()
                                  ? GenerateName(":var", name_index_++)
                                  : H.DartSymbol(declaration->name());
   LocalVariable* variable =
-      MakeVariable(name, T.TranslateVariableType(declaration));
+      MakeVariable(declaration->position(), declaration->end_position(), name,
+                   T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->AddVariable(variable);
   result_->locals.Insert(declaration, variable);
 }
 
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
@@ skipping 29 matching lines @@
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
 
   LocalScope* enclosing_scope = NULL;
   if (function.IsLocalFunction()) {
     enclosing_scope = LocalScope::RestoreOuterScope(
         ContextScope::Handle(Z, function.context_scope()));
   }
   current_function_scope_ = scope_ = new (Z) LocalScope(enclosing_scope, 0, 0);
+  scope_->set_begin_token_pos(function.token_pos());
+  scope_->set_end_token_pos(function.end_token_pos());
 
   LocalVariable* context_var = parsed_function->current_context_var();
   context_var->set_is_forced_stack();
   scope_->AddVariable(context_var);
   scope_->AddVariable(parsed_function->EnsureExpressionTemp());
 
   parsed_function->SetNodeSequence(
       new SequenceNode(TokenPosition::kNoSource, scope_));
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor: {
       FunctionNode* node;
       if (node_->IsProcedure()) {
         node = Procedure::Cast(node_)->function();
       } else if (node_->IsConstructor()) {
         node = Constructor::Cast(node_)->function();
       } else {
         node = FunctionNode::Cast(node_);
       }
       current_function_node_ = node;
 
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
-        LocalVariable* variable = MakeVariable(Symbols::ClosureParameter(),
-                                               AbstractType::dynamic_type());
+        LocalVariable* variable = MakeVariable(
+            TokenPosition::kNoSource, TokenPosition::kNoSource,
+            Symbols::ClosureParameter(), AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
-        LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+        LocalVariable* variable =
+            MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                         Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
 
         // We visit instance field initializers because they might contain
         // [Let] expressions and we need to have a mapping.
         if (node_->IsConstructor()) {
           Class* klass = Class::Cast(Constructor::Cast(node_)->parent());
 
           for (intptr_t i = 0; i < klass->fields().length(); i++) {
             Field* field = klass->fields()[i];
             if (!field->IsStatic() && (field->initializer() != NULL)) {
-              EnterScope(field);
+              EnterScope(field, field->position());
               field->initializer()->AcceptExpressionVisitor(this);
-              ExitScope();
+              ExitScope(field->end_position());
             }
           }
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
+            TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
       AddParameters(node, pos);
 
       // We generate a syntethic body for implicit closure functions - which
       // will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
       if (!function.IsImplicitClosureFunction()) {
         node_->AcceptVisitor(this);
       }
       break;
     }
     case RawFunction::kImplicitGetter:
     case RawFunction::kImplicitStaticFinalGetter:
     case RawFunction::kImplicitSetter: {
       ASSERT(node_->IsField());
       if (IsStaticInitializer(function, Z)) {
         node_->AcceptVisitor(this);
         break;
       }
       bool is_setter = function.IsImplicitSetterFunction();
       bool is_method = !function.IsStaticFunction();
       intptr_t pos = 0;
       if (is_method) {
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
-        LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+        LocalVariable* variable =
+            MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                         Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
       }
       if (is_setter) {
         result_->setter_value =
-            MakeVariable(Symbols::Value(), AbstractType::dynamic_type());
+            MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                         Symbols::Value(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, result_->setter_value);
       }
       break;
     }
     case RawFunction::kMethodExtractor: {
       // Add a receiver parameter.  Though it is captured, we emit code to
       // explicitly copy it to a fixed offset in a freshly-allocated context
       // instead of using the generic code for regular functions.
       // Therefore, it isn't necessary to mark it as captured here.
       dart::Class& klass = dart::Class::Handle(Z, function.Owner());
       Type& klass_type = H.GetCanonicalType(klass);
-      LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+      LocalVariable* variable =
+          MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                       Symbols::This(), klass_type);
       scope_->InsertParameterAt(0, variable);
       result_->this_variable = variable;
       break;
     }
     case RawFunction::kNoSuchMethodDispatcher:
     case RawFunction::kInvokeFieldDispatcher:
       for (intptr_t i = 0; i < function.NumParameters(); ++i) {
         LocalVariable* variable = MakeVariable(
+            TokenPosition::kNoSource, TokenPosition::kNoSource,
             dart::String::ZoneHandle(Z, function.ParameterNameAt(i)),
             AbstractType::dynamic_type());
         scope_->InsertParameterAt(i, variable);
       }
       break;
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       UNREACHABLE();
   }
 
@@ skipping 37 matching lines @@
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::HandleLocalFunction(TreeNode* parent,
                                        FunctionNode* function) {
   LocalScope* saved_function_scope = current_function_scope_;
   FunctionNode* saved_function_node = current_function_node_;
   ScopeBuilder::DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
-  EnterScope(parent);
+  EnterScope(parent, function->position());
   current_function_scope_ = scope_;
   current_function_node_ = function;
   if (depth_.function_ == 1) {
     FunctionScope function_scope = {function, scope_};
     result_->function_scopes.Add(function_scope);
   }
   AddParameters(function);
   VisitFunctionNode(function);
-  ExitScope();
+  ExitScope(function->end_position());
   depth_ = saved_depth_state;
   current_function_scope_ = saved_function_scope;
   current_function_node_ = saved_function_node;
 }
 
 
 void ScopeBuilder::HandleSpecialLoad(LocalVariable** variable,
                                      const dart::String& symbol) {
   if (current_function_scope_->parent() != NULL) {
     // We are building the scope tree of a closure function and saw [node]. We
@@ skipping 14 matching lines @@
   }
 }
 
 
 void ScopeBuilder::VisitFunctionExpression(FunctionExpression* node) {
   HandleLocalFunction(node, node->function());
 }
 
 
 void ScopeBuilder::VisitLet(Let* node) {
-  EnterScope(node);
+  EnterScope(node, node->position());
   node->VisitChildren(this);
-  ExitScope();
+  ExitScope(node->end_position());
 }
 
 
 void ScopeBuilder::VisitBlock(Block* node) {
-  EnterScope(node);
+  EnterScope(node, node->position());
   node->VisitChildren(this);
-  ExitScope();
+  ExitScope(node->end_position());
 }
 
 
 void ScopeBuilder::VisitVariableDeclaration(VariableDeclaration* node) {
   AddVariable(node);
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitFunctionDeclaration(FunctionDeclaration* node) {
@@ skipping 10 matching lines @@
 
 
 void ScopeBuilder::VisitDoStatement(DoStatement* node) {
   ++depth_.loop_;
   node->VisitChildren(this);
   --depth_.loop_;
 }
 
 
 void ScopeBuilder::VisitForStatement(ForStatement* node) {
-  EnterScope(node);
+  EnterScope(node, node->position());
   List<VariableDeclaration>& variables = node->variables();
   for (intptr_t i = 0; i < variables.length(); ++i) {
     VisitVariableDeclaration(variables[i]);
   }
   ++depth_.loop_;
   if (node->condition() != NULL) {
     node->condition()->AcceptExpressionVisitor(this);
   }
   node->body()->AcceptStatementVisitor(this);
   List<Expression>& updates = node->updates();
   for (intptr_t i = 0; i < updates.length(); ++i) {
     updates[i]->AcceptExpressionVisitor(this);
   }
   --depth_.loop_;
-  ExitScope();
+  ExitScope(node->end_position());
 }
 
 
 void ScopeBuilder::VisitForInStatement(ForInStatement* node) {
   node->iterable()->AcceptExpressionVisitor(this);
   ++depth_.for_in_;
   AddIteratorVariable();
   ++depth_.loop_;
-  EnterScope(node);
+  EnterScope(node, node->position());
   VisitVariableDeclaration(node->variable());
   node->body()->AcceptStatementVisitor(this);
-  ExitScope();
+  ExitScope(node->end_position());
   --depth_.loop_;
   --depth_.for_in_;
 }
 
 
 void ScopeBuilder::AddSwitchVariable() {
   if ((depth_.function_ == 0) && (result_->switch_variable == NULL)) {
     LocalVariable* variable =
-        MakeVariable(Symbols::SwitchExpr(), AbstractType::dynamic_type());
+        MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                     Symbols::SwitchExpr(), AbstractType::dynamic_type());
     variable->set_is_forced_stack();
     current_function_scope_->AddVariable(variable);
     result_->switch_variable = variable;
   }
 }
 
 
 void ScopeBuilder::VisitSwitchStatement(SwitchStatement* node) {
   AddSwitchVariable();
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitReturnStatement(ReturnStatement* node) {
   if ((depth_.function_ == 0) && (depth_.finally_ > 0) &&
       (result_->finally_return_variable == NULL)) {
     const dart::String& name = H.DartSymbol(":try_finally_return_value");
-    LocalVariable* variable = MakeVariable(name, AbstractType::dynamic_type());
+    LocalVariable* variable =
+        MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource, name,
+                     AbstractType::dynamic_type());
     current_function_scope_->AddVariable(variable);
     result_->finally_return_variable = variable;
   }
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitTryCatch(TryCatch* node) {
   ++depth_.try_;
   AddTryVariables();
   node->body()->AcceptStatementVisitor(this);
   --depth_.try_;
 
   ++depth_.catch_;
   AddCatchVariables();
   List<Catch>& catches = node->catches();
   for (intptr_t i = 0; i < catches.length(); ++i) {
     Catch* ketch = catches[i];
-    EnterScope(ketch);
+    EnterScope(ketch, ketch->position());
     if (ketch->exception() != NULL) {
       VisitVariableDeclaration(ketch->exception());
     }
     if (ketch->stack_trace() != NULL) {
       VisitVariableDeclaration(ketch->stack_trace());
     }
     ketch->body()->AcceptStatementVisitor(this);
-    ExitScope();
+    ExitScope(ketch->end_position());
   }
   --depth_.catch_;
 }
 
 
 void ScopeBuilder::VisitTryFinally(TryFinally* node) {
   ++depth_.try_;
   ++depth_.finally_;
   AddTryVariables();
   node->body()->AcceptStatementVisitor(this);
@@ skipping 1349 matching lines @@
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::AdjustContextTo(int depth) {
   ASSERT(depth <= context_depth_ && depth >= 0);
   Fragment instructions;
   if (depth < context_depth_) {
     instructions += LoadContextAt(depth);
-    instructions += StoreLocal(parsed_function_->current_context_var());
+    instructions += StoreLocal(TokenPosition::kNoSource,
+                               parsed_function_->current_context_var());
     instructions += Drop();
     context_depth_ = depth;
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::PushContext(int size) {
   ASSERT(size > 0);
   Fragment instructions = AllocateContext(size);
   LocalVariable* context = MakeTemporary();
   instructions += LoadLocal(context);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Context::parent_offset());
-  instructions += StoreLocal(parsed_function_->current_context_var());
+  instructions += StoreLocal(TokenPosition::kNoSource,
+                             parsed_function_->current_context_var());
   ++context_depth_;
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::PopContext() {
   return AdjustContextTo(context_depth_ - 1);
 }
 
 
@@ skipping 179 matching lines @@
   // :saved_try_context_var can be captured in the context of
   // of the closure, in this case CatchBlockEntryInstr restores
   // :current_context_var to point to closure context in the
   // same way as normal function prologue does.
   // Update current context depth to reflect that.
   const intptr_t saved_context_depth = context_depth_;
   ASSERT(!CurrentCatchContext()->is_captured() ||
          CurrentCatchContext()->owner()->context_level() == 0);
   context_depth_ = 0;
   instructions += LoadLocal(CurrentCatchContext());
-  instructions += StoreLocal(parsed_function_->current_context_var());
+  instructions += StoreLocal(TokenPosition::kNoSource,
+                             parsed_function_->current_context_var());
   instructions += Drop();
   context_depth_ = saved_context_depth;
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::TryCatch(int try_handler_index) {
   // The body of the try needs to have it's own block in order to get a new try
   // index.
   //
   // => We therefore create a block for the body (fresh try index) and another
   //    join block (with current try index).
   Fragment body;
   JoinEntryInstr* entry =
       new (Z) JoinEntryInstr(AllocateBlockId(), try_handler_index);
   body += LoadLocal(parsed_function_->current_context_var());
-  body += StoreLocal(CurrentCatchContext());
+  body += StoreLocal(TokenPosition::kNoSource, CurrentCatchContext());
   body += Drop();
   body += Goto(entry);
   return Fragment(body.entry, entry);
 }
 
 
 Fragment FlowGraphBuilder::CheckStackOverflowInPrologue() {
   if (IsInlining()) {
     // If we are inlining don't actually attach the stack check.  We must still
     // create the stack check in order to allocate a deopt id.
@@ skipping 13 matching lines @@
 Fragment FlowGraphBuilder::CloneContext() {
   LocalVariable* context_variable = parsed_function_->current_context_var();
 
   Fragment instructions = LoadLocal(context_variable);
 
   CloneContextInstr* clone_instruction =
       new (Z) CloneContextInstr(TokenPosition::kNoSource, Pop());
   instructions <<= clone_instruction;
   Push(clone_instruction);
 
-  instructions += StoreLocal(context_variable);
+  instructions += StoreLocal(TokenPosition::kNoSource, context_variable);
   instructions += Drop();
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::Constant(const Object& value) {
   ASSERT(value.IsNotTemporaryScopedHandle());
   ConstantInstr* constant = new (Z) ConstantInstr(value);
   Push(constant);
   return Fragment(constant);
@@ skipping 189 matching lines @@
   PushArgumentInstr* argument = new (Z) PushArgumentInstr(Pop());
   Push(argument);
 
   argument->set_temp_index(argument->temp_index() - 1);
   ++pending_argument_count_;
 
   return Fragment(argument);
 }
 
 
-Fragment FlowGraphBuilder::Return() {
+Fragment FlowGraphBuilder::Return(TokenPosition position) {
   Value* value = Pop();
   ASSERT(stack_ == NULL);
   ReturnInstr* return_instr =
       new (Z) ReturnInstr(TokenPosition::kNoSource, value);
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
   return Fragment(return_instr).closed();
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
@@ skipping 94 matching lines @@
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, Pop(), value, emit_store_barrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
-Fragment FlowGraphBuilder::StoreLocal(LocalVariable* variable) {
+Fragment FlowGraphBuilder::StoreLocal(TokenPosition position,
+                                      LocalVariable* variable) {
   Fragment instructions;
   if (variable->is_captured()) {
     LocalVariable* value = MakeTemporary();
     instructions += LoadContextAt(variable->owner()->context_level());
     instructions += LoadLocal(value);
     instructions +=
         StoreInstanceField(Context::variable_offset(variable->index()));
   } else {
+    Value* value = Pop();
     StoreLocalInstr* store =
-        new (Z) StoreLocalInstr(*variable, Pop(), TokenPosition::kNoSource);
+        new (Z) StoreLocalInstr(*variable, value, position);
     instructions <<= store;
     Push(store);
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreStaticField(const dart::Field& field) {
   return Fragment(new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(),
                                                 TokenPosition::kNoSource));
 }
 
 
-Fragment FlowGraphBuilder::StringInterpolate() {
+Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
-      new (Z) StringInterpolateInstr(array, TokenPosition::kNoSource);
+      new (Z) StringInterpolateInstr(array, position);
   Push(interpolate);
   return Fragment(interpolate);
 }
 
 
 Fragment FlowGraphBuilder::ThrowTypeError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::TypeError()));
   ASSERT(!klass.IsNull());
   const dart::Function& constructor = dart::Function::ZoneHandle(
@@ skipping 345 matching lines @@
         // try/catch.
         parameter->set_is_captured_parameter(true);
 
         // Copy the parameter from the stack to the context.  Overwrite it
         // with a null constant on the stack so the original value is
         // eligible for garbage collection.
         body += LoadLocal(context);
         body += LoadLocal(parameter);
         body += StoreInstanceField(Context::variable_offset(variable->index()));
         body += NullConstant();
-        body += StoreLocal(parameter);
+        body += StoreLocal(TokenPosition::kNoSource, parameter);
         body += Drop();
       }
     }
     body += Drop();  // The context.
   }
   if (constructor != NULL) {
     // TODO(27590): Currently the [VariableDeclaration]s from the
     // initializers will be visible inside the entire body of the constructor.
     // We should make a separate scope for them.
     Class* kernel_klass = Class::Cast(constructor->parent());
@@ skipping 21 matching lines @@
     TargetEntryInstr* non_null_entry;
 
     body += LoadLocal(parameter);
     body += BranchIfNull(&null_entry, &non_null_entry);
 
     // The argument was `null` and the receiver is not the null class (we only
     // go into this branch for user-defined == operators) so we can return
     // false.
     Fragment null_fragment(null_entry);
     null_fragment += Constant(Bool::False());
-    null_fragment += Return();
+    null_fragment += Return(dart_function.end_token_pos());
 
     body = Fragment(body.entry, non_null_entry);
   }
 
   if (dart_function.is_native()) {
     body += NativeFunctionBody(function, dart_function);
   } else if (function->body() != NULL) {
     body += TranslateStatement(function->body());
   }
   if (body.is_open()) {
     body += NullConstant();
-    body += Return();
+    body += Return(dart_function.end_token_pos());
   }
 
   // If functions body contains any yield points build switch statement that
   // selects a continuation point based on the value of :await_jump_var.
   if (!yield_continuations_.is_empty()) {
     // The code we are building will be executed right after we enter
     // the function and before any nested contexts are allocated.
     // Reset current context_depth_ to match this.
     intptr_t current_context_depth = context_depth_;
     context_depth_ = scopes_->yield_jump_variable->owner()->context_level();
 
     // Prepend an entry corresponding to normal entry to the function.
     yield_continuations_.InsertAt(
         0, YieldContinuation(new (Z) DropTempsInstr(0, NULL),
                              CatchClauseNode::kInvalidTryIndex));
     yield_continuations_[0].entry->LinkTo(body.entry);
 
     // Build a switch statement.
     Fragment dispatch;
 
     // Load :await_jump_var into a temporary.
     dispatch += LoadLocal(scopes_->yield_jump_variable);
-    dispatch += StoreLocal(scopes_->switch_variable);
+    dispatch += StoreLocal(TokenPosition::kNoSource, scopes_->switch_variable);
     dispatch += Drop();
 
     BlockEntryInstr* block = NULL;
     for (intptr_t i = 0; i < yield_continuations_.length(); i++) {
       if (i == 1) {
         // This is not a normal entry but a resumption.  Restore
         // :current_context_var from :await_ctx_var.
         // Note: after this point context_depth_ does not match current context
         // depth so we should not access any local variables anymore.
         dispatch += LoadLocal(scopes_->yield_context_variable);
-        dispatch += StoreLocal(parsed_function_->current_context_var());
+        dispatch += StoreLocal(TokenPosition::kNoSource,
+                               parsed_function_->current_context_var());
         dispatch += Drop();
       }
       if (i == (yield_continuations_.length() - 1)) {
         // We reached the last possility, no need to build more ifs.
         // Coninue to the last continuation.
         // Note: continuations start with nop DropTemps instruction
         // which acts like an anchor, so we need to skip it.
         block->set_try_index(yield_continuations_[i].try_index);
         dispatch <<= yield_continuations_[i].entry->next();
         break;
@@ skipping 18 matching lines @@
       then->set_try_index(yield_continuations_[i].try_index);
 
       // False branch will contain the next comparison.
       dispatch = Fragment(dispatch.entry, otherwise);
       block = otherwise;
     }
     body = dispatch;
 
     context_depth_ = current_context_depth;
   }
+
   normal_entry->LinkTo(body.entry);
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
     BitVector* block_marks = new (Z) BitVector(Z, next_block_id_);
     bool found = graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_,
                                                 block_marks);
     ASSERT(found);
@@ skipping 147 matching lines @@
       body += LoadLocal(scopes_->this_variable);
       body += LoadNativeField(kind, Bigint::neg_offset(),
                               Type::ZoneHandle(Z, Type::BoolType()), kBoolCid);
       break;
     default: {
       dart::String& name = dart::String::ZoneHandle(Z, function.native_name());
       body += NativeCall(&name, &function);
       break;
     }
   }
-  return body + Return();
+  return body + Return(TokenPosition::kNoSource);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
     Field* kernel_field,
     LocalVariable* setter_value) {
   const dart::Function& function = parsed_function_->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
@@ skipping 30 matching lines @@
     body += Constant(constant_evaluator_.EvaluateExpression(initializer));
   } else {
     // The field always has an initializer because static fields without
     // initializers are initialized eagerly and do not have implicit getters.
     ASSERT(field.has_initializer());
     body += Constant(field);
     body += InitStaticField(field);
     body += Constant(field);
     body += LoadStaticField();
   }
-  body += Return();
+  body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfStaticFieldInitializer(
     Field* kernel_field) {
   ASSERT(kernel_field->IsStatic());
 
   Expression* initializer = kernel_field->initializer();
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
   if (kernel_field->IsConst()) {
     body += Constant(constant_evaluator_.EvaluateExpression(initializer));
   } else {
     body += TranslateExpression(initializer);
   }
-  body += Return();
+  body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 Fragment FlowGraphBuilder::BuildImplicitClosureCreation(
     const Function& target) {
   Fragment fragment;
   const dart::Class& closure_class =
       dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
@@ skipping 40 matching lines @@
   // A method extractor is the implicit getter for a method.
   const Function& function =
       Function::ZoneHandle(Z, method.extracted_method_closure());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
   body += BuildImplicitClosureCreation(function);
-  body += Return();
+  body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfImplicitClosureFunction(
     FunctionNode* kernel_function,
     const Function& function) {
   const Function& target = Function::ZoneHandle(Z, function.parent_function());
 
@@ skipping 31 matching lines @@
       argument_names.SetAt(i, H.DartSymbol(variable->name()));
     }
   }
   // Forward them to the target.
   intptr_t argument_count = positional_argument_count + named_argument_count;
   if (!target.is_static()) ++argument_count;
   body += StaticCall(TokenPosition::kNoSource, target, argument_count,
                      argument_names);
 
   // Return the result.
-  body += Return();
+  body += Return(kernel_function->end_position());
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfNoSuchMethodDispatcher(
     const Function& function) {
   // This function is specialized for a receiver class, a method name, and
   // the arguments descriptor at a call site.
 
@@ skipping 80 matching lines @@
                                   dart::Class::Handle(Z, function.Owner()),
                                   Symbols::NoSuchMethod(), two_arguments));
   if (no_such_method.IsNull()) {
     // If noSuchMethod is not found on the receiver class, call
     // Object.noSuchMethod.
     no_such_method = Resolver::ResolveDynamicForReceiverClass(
         dart::Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), two_arguments);
   }
   body += StaticCall(TokenPosition::kMinSource, no_such_method, 2);
-  body += Return();
+  body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
     const Function& function) {
   // Find the name of the field we should dispatch to.
   const dart::Class& owner = dart::Class::Handle(Z, function.Owner());
   ASSERT(!owner.IsNull());
@@ skipping 66 matching lines @@
     // Lookup the function in the closure.
     body += LoadLocal(closure);
     body += LoadField(Closure::function_offset());
 
     body += ClosureCall(descriptor.Count(), argument_names);
   } else {
     body += InstanceCall(TokenPosition::kMinSource, Symbols::Call(),
                          Token::kILLEGAL, descriptor.Count(), argument_names);
   }
 
-  body += Return();
+  body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 void FlowGraphBuilder::SetupDefaultParameterValues(FunctionNode* function) {
   intptr_t num_optional_parameters =
       parsed_function_->function().NumOptionalParameters();
   if (num_optional_parameters > 0) {
     ZoneGrowableArray<const Instance*>* default_values =
@@ skipping 138 matching lines @@
       //  specification but that is how it is currently implemented.)
       LocalInitializer* init = LocalInitializer::Cast(initializer);
 
       VariableDeclaration* declaration = init->variable();
       LocalVariable* variable = LookupVariable(declaration);
       Expression* initializer = init->variable()->initializer();
       ASSERT(initializer != NULL);
       ASSERT(!declaration->IsConst());
 
       instructions += TranslateExpression(initializer);
-      instructions += StoreLocal(variable);
+      instructions += StoreLocal(TokenPosition::kNoSource, variable);
       instructions += Drop();
 
       fragment_ = instructions;
     } else {
       UNIMPLEMENTED();
     }
   }
   return instructions;
 }
 
@@ skipping 391 matching lines @@
 }
 
 
 void FlowGraphBuilder::VisitVariableGet(VariableGet* node) {
   fragment_ = LoadLocal(LookupVariable(node->variable()));
 }
 
 
 void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
   Fragment instructions = TranslateExpression(node->expression());
-  instructions += StoreLocal(LookupVariable(node->variable()));
+  instructions +=
+      StoreLocal(node->position(), LookupVariable(node->variable()));
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
   Member* target = node->target();
   if (target->IsField()) {
     Field* kernel_field = Field::Cast(target);
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
@@ skipping 74 matching lines @@
               InstanceCall(node->position(), getter_name, Token::kGET, 1);
 }
 
 
 void FlowGraphBuilder::VisitPropertySet(PropertySet* node) {
   Fragment instructions(NullConstant());
   LocalVariable* variable = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
-  instructions += StoreLocal(variable);
+  instructions += StoreLocal(TokenPosition::kNoSource, variable);
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
   instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
   Function& target = Function::ZoneHandle(Z);
@@ skipping 28 matching lines @@
   const dart::String& method_name = H.DartSetterName(node->target()->name());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
   ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
 
   Fragment instructions(NullConstant());
   LocalVariable* value = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
-  instructions += StoreLocal(value);
+  instructions += StoreLocal(TokenPosition::kNoSource, value);
   instructions += PushArgument();
   instructions += StaticCall(node->position(), target, 2);
 
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitStaticInvocation(StaticInvocation* node) {
   const Function& target = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(node->procedure()));
@@ skipping 246 matching lines @@
     }
     instructions += PushArgument();  // Type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += Constant(Bool::False());
     instructions += PushArgument();  // Negate?.
 
     instructions +=
-        InstanceCall(TokenPosition::kNoSource,
+        InstanceCall(node->position(),
                      dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
                      Token::kIS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitAsExpression(AsExpression* node) {
   Fragment instructions = TranslateExpression(node->operand());
@@ skipping 39 matching lines @@
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
 
   TargetEntryInstr* then_entry;
   TargetEntryInstr* otherwise_entry;
   instructions += BranchIfTrue(&then_entry, &otherwise_entry, negate);
 
   Value* top = stack_;
   Fragment then_fragment(then_entry);
   then_fragment += TranslateExpression(node->then());
-  then_fragment += StoreLocal(parsed_function_->expression_temp_var());
+  then_fragment += StoreLocal(TokenPosition::kNoSource,
+                              parsed_function_->expression_temp_var());
   then_fragment += Drop();
   ASSERT(stack_ == top);
 
   Fragment otherwise_fragment(otherwise_entry);
   otherwise_fragment += TranslateExpression(node->otherwise());
-  otherwise_fragment += StoreLocal(parsed_function_->expression_temp_var());
+  otherwise_fragment += StoreLocal(TokenPosition::kNoSource,
+                                   parsed_function_->expression_temp_var());
   otherwise_fragment += Drop();
   ASSERT(stack_ == top);
 
   JoinEntryInstr* join = BuildJoinEntry();
   then_fragment += Goto(join);
   otherwise_fragment += Goto(join);
 
   fragment_ = Fragment(instructions.entry, join) +
               LoadLocal(parsed_function_->expression_temp_var());
 }
@@ skipping 10 matching lines @@
   } else {
     instructions += BranchIfTrue(&constant_entry, &right_entry, negate);
   }
 
   Value* top = stack_;
   Fragment right_fragment(right_entry);
   right_fragment += TranslateCondition(node->right(), &negate);
   right_fragment += Constant(Bool::True());
   right_fragment +=
       StrictCompare(negate ? Token::kNE_STRICT : Token::kEQ_STRICT);
-  right_fragment += StoreLocal(parsed_function_->expression_temp_var());
+  right_fragment += StoreLocal(TokenPosition::kNoSource,
+                               parsed_function_->expression_temp_var());
   right_fragment += Drop();
 
   ASSERT(top == stack_);
   Fragment constant_fragment(constant_entry);
   constant_fragment +=
       Constant(Bool::Get(node->op() == LogicalExpression::kOr));
-  constant_fragment += StoreLocal(parsed_function_->expression_temp_var());
+  constant_fragment += StoreLocal(TokenPosition::kNoSource,
+                                  parsed_function_->expression_temp_var());
   constant_fragment += Drop();
 
   JoinEntryInstr* join = BuildJoinEntry();
   right_fragment += Goto(join);
   constant_fragment += Goto(join);
 
   fragment_ = Fragment(instructions.entry, join) +
               LoadLocal(parsed_function_->expression_temp_var());
 }
 
@@ skipping 21 matching lines @@
   LocalVariable* array = MakeTemporary();
 
   for (intptr_t i = 0; i < node->expressions().length(); i++) {
     instructions += LoadLocal(array);
     instructions += IntConstant(i);
     instructions += TranslateExpression(node->expressions()[i]);
     instructions += StoreIndexed(kArrayCid);
     instructions += Drop();
   }
 
-  instructions += StringInterpolate();
+  instructions += StringInterpolate(node->position());
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitListLiteral(ListLiteral* node) {
   if (node->is_const()) {
     fragment_ = Constant(constant_evaluator_.EvaluateListLiteral(node));
     return;
   }
@@ skipping 171 matching lines @@
 
 void FlowGraphBuilder::VisitReturnStatement(ReturnStatement* node) {
   bool inside_try_finally = try_finally_block_ != NULL;
 
   Fragment instructions = node->expression() == NULL
                               ? NullConstant()
                               : TranslateExpression(node->expression());
   if (instructions.is_open()) {
     if (inside_try_finally) {
       ASSERT(scopes_->finally_return_variable != NULL);
-      instructions += StoreLocal(scopes_->finally_return_variable);
+      instructions += StoreLocal(TokenPosition::kNoSource,
+                                 scopes_->finally_return_variable);
       instructions += Drop();
       instructions += TranslateFinallyFinalizers(NULL, -1);
       if (instructions.is_open()) {
         instructions += LoadLocal(scopes_->finally_return_variable);
-        instructions += Return();
+        instructions += Return(node->position());
       }
     } else {
-      instructions += Return();
+      instructions += Return(node->position());
     }
   } else {
     Pop();
   }
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitExpressionStatement(ExpressionStatement* node) {
   Fragment instructions = TranslateExpression(node->expression());
@@ skipping 12 matching lines @@
   } else {
     if (node->IsConst()) {
       const Instance& constant_value =
           constant_evaluator_.EvaluateExpression(initializer);
       variable->SetConstValue(constant_value);
       instructions += Constant(constant_value);
     } else {
       instructions += TranslateExpression(initializer);
     }
   }
-  instructions += StoreLocal(variable);
+  instructions += StoreLocal(variable->token_pos(), variable);
   instructions += Drop();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitFunctionDeclaration(FunctionDeclaration* node) {
   Fragment instructions = TranslateFunctionNode(node->function(), node);
-  instructions += StoreLocal(LookupVariable(node->variable()));
+  instructions +=
+      StoreLocal(TokenPosition::kNoSource, LookupVariable(node->variable()));
   instructions += Drop();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitIfStatement(IfStatement* node) {
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
   TargetEntryInstr* then_entry;
   TargetEntryInstr* otherwise_entry;
@@ skipping 138 matching lines @@
 
 void FlowGraphBuilder::VisitForInStatement(ForInStatement* node) {
   Fragment instructions = TranslateExpression(node->iterable());
   instructions += PushArgument();
 
   const dart::String& iterator_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Iterator()));
   instructions +=
       InstanceCall(TokenPosition::kNoSource, iterator_getter, Token::kGET, 1);
   LocalVariable* iterator = scopes_->iterator_variables[for_in_depth_];
-  instructions += StoreLocal(iterator);
+  instructions += StoreLocal(TokenPosition::kNoSource, iterator);
   instructions += Drop();
 
   ++for_in_depth_;
   ++loop_depth_;
   Fragment condition = LoadLocal(iterator);
   condition += PushArgument();
   condition += InstanceCall(TokenPosition::kNoSource, Symbols::MoveNext(),
                             Token::kILLEGAL, 1);
   TargetEntryInstr* body_entry;
   TargetEntryInstr* loop_exit;
   condition += BranchIfTrue(&body_entry, &loop_exit);
 
   Fragment body(body_entry);
   body += EnterScope(node);
   body += LoadLocal(iterator);
   body += PushArgument();
   const dart::String& current_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Current()));
   body +=
       InstanceCall(TokenPosition::kNoSource, current_getter, Token::kGET, 1);
-  body += StoreLocal(LookupVariable(node->variable()));
+  body +=
+      StoreLocal(TokenPosition::kNoSource, LookupVariable(node->variable()));
   body += Drop();
   body += TranslateStatement(node->body());
   body += ExitScope(node);
 
   if (body.is_open()) {
     JoinEntryInstr* join = BuildJoinEntry();
     instructions += Goto(join);
     body += Goto(join);
 
     Fragment loop(join);
@@ skipping 49 matching lines @@
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitSwitchStatement(SwitchStatement* node) {
   SwitchBlock block(this, node);
 
   // Instead of using a variable we should reuse the expression on the stack,
   // since it won't be assigned again, we don't need phi nodes.
   Fragment head_instructions = TranslateExpression(node->condition());
-  head_instructions += StoreLocal(scopes_->switch_variable);
+  head_instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes_->switch_variable);
   head_instructions += Drop();
 
   // Phase 1: Generate bodies and try to find out whether a body will be target
   // of a jump due to:
   //   * `continue case_label`
   //   * `case e1: case e2: body`
   Fragment* body_fragments = new Fragment[node->cases().length()];
 
   intptr_t num_cases = node->cases().length();
   for (intptr_t i = 0; i < num_cases; i++) {
@@ skipping 334 matching lines @@
   // Fill in the body of the catch.
   for (intptr_t i = 0; i < node->catches().length(); i++) {
     Catch* catch_clause = node->catches()[i];
 
     Fragment catch_handler_body;
 
     catch_handler_body += EnterScope(catch_clause);
 
     if (catch_clause->exception() != NULL) {
       catch_handler_body += LoadLocal(CurrentException());
-      catch_handler_body +=
-          StoreLocal(LookupVariable(catch_clause->exception()));
+      catch_handler_body += StoreLocal(
+          TokenPosition::kNoSource, LookupVariable(catch_clause->exception()));
       catch_handler_body += Drop();
     }
     if (catch_clause->stack_trace() != NULL) {
       catch_handler_body += LoadLocal(CurrentStackTrace());
       catch_handler_body +=
-          StoreLocal(LookupVariable(catch_clause->stack_trace()));
+          StoreLocal(TokenPosition::kNoSource,
+                     LookupVariable(catch_clause->stack_trace()));
       catch_handler_body += Drop();
     }
     AbstractType* type_guard = NULL;
     if (catch_clause->guard() != NULL &&
         !catch_clause->guard()->IsDynamicType()) {
       type_guard = &T.TranslateType(catch_clause->guard());
       handler_types.SetAt(i, *type_guard);
     } else {
       handler_types.SetAt(i, Object::dynamic_type());
     }
@@ skipping 69 matching lines @@
   //   return <expr>
   //
   // Continuation<index>:
   //   Drop(1)
   //   ...
   //
   // BuildGraphOfFunction will create a dispatch that jumps to
   // Continuation<:await_jump_var> upon entry to the function.
   //
   Fragment instructions = IntConstant(yield_continuations_.length() + 1);
-  instructions += StoreLocal(scopes_->yield_jump_variable);
+  instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes_->yield_jump_variable);
   instructions += Drop();
   instructions += LoadLocal(parsed_function_->current_context_var());
-  instructions += StoreLocal(scopes_->yield_context_variable);
+  instructions +=
+      StoreLocal(TokenPosition::kNoSource, scopes_->yield_context_variable);
   instructions += Drop();
   instructions += TranslateExpression(node->expression());
-  instructions += Return();
+  instructions += Return(TokenPosition::kNoSource);
 
   // Note: DropTempsInstr serves as an anchor instruction. It will not
   // be linked into the resulting graph.
   DropTempsInstr* anchor = new (Z) DropTempsInstr(0, NULL);
   yield_continuations_.Add(YieldContinuation(anchor, CurrentTryIndex()));
 
   Fragment continuation(instructions.entry, anchor);
 
   // TODO(27590): we need a better way to detect if we need to check for an
   // exception after yield or not.
@@ skipping 34 matching lines @@
     continuation = Fragment(continuation.entry, no_error);
   }
 
   fragment_ = continuation;
 }
 
 
 Fragment FlowGraphBuilder::TranslateFunctionNode(FunctionNode* node,
                                                  TreeNode* parent) {
   // The VM has a per-isolate table of functions indexed by the enclosing
-  // function and token position.  We don't have token positions, so we've
-  // simply numbered the immediately-nested functions with respect to the
-  // parent.
+  // function and token position.
   Function& function = Function::ZoneHandle(Z);
   for (intptr_t i = 0; i < scopes_->function_scopes.length(); ++i) {
     if (scopes_->function_scopes[i].function != node) continue;
 
+    TokenPosition position = node->position();
+    if (parent->IsFunctionDeclaration()) {
+      position = FunctionDeclaration::Cast(parent)->position();
+    }
+    if (!position.IsReal()) {
+      // Positions has to be unique in regards to the parent.
+      // A non-real at this point is probably -1, we cannot blindly use that
+      // as others might use it too. Create a new dummy non-real TokenPosition.
+      position = TokenPosition(i).ToSynthetic();
+    }
+
     // NOTE: This is not TokenPosition in the general sense!
-    function = I->LookupClosureFunction(parsed_function_->function(),
-                                        TokenPosition(i));
+    function = I->LookupClosureFunction(parsed_function_->function(), position);
     if (function.IsNull()) {
       const dart::String* name;
       if (parent->IsFunctionExpression()) {
         name = &Symbols::AnonymousClosure();
       } else {
         ASSERT(parent->IsFunctionDeclaration());
         name = &H.DartSymbol(
             FunctionDeclaration::Cast(parent)->variable()->name());
       }
       // NOTE: This is not TokenPosition in the general sense!
       function = Function::NewClosureFunction(
-          *name, parsed_function_->function(), TokenPosition(i));
-      function.set_is_debuggable(false);
+          *name, parsed_function_->function(), position);
+      function.set_is_debuggable(node->debuggable());
+      function.set_end_token_pos(node->end_position());
       LocalScope* scope = scopes_->function_scopes[i].scope;
       const ContextScope& context_scope =
           ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_function(node);
       KernelReader::SetupFunctionParameters(H, T, dart::Class::Handle(Z),
                                             function, node,
                                             false,  // is_method
                                             true);  // is_closure
       // Finalize function type.
@@ skipping 24 matching lines @@
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)