Add local variable declaration token position to service protocol

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 23 matching lines @@
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   result_->scopes.Insert(node, scope_);
 }
 
 
 void ScopeBuilder::ExitScope() { scope_ = scope_->parent(); }
 
 
 LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name) {
   return new (Z)
-      LocalVariable(TokenPosition::kNoSource, name, Object::dynamic_type());
+      LocalVariable(TokenPosition::kNoSource,
+                    TokenPosition::kNoSource,
+                    name,
+                    Object::dynamic_type());
 }
 
 
 LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name,
                                           const Type& type) {
-  return new (Z) LocalVariable(TokenPosition::kNoSource, name, type);
+  return new (Z) LocalVariable(TokenPosition::kNoSource,
+                               TokenPosition::kNoSource,
+                               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) {
@@ skipping 2435 matching lines @@
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
   char name[64];
   intptr_t index = stack_->definition()->temp_index();
   OS::SNPrint(name, 64, ":temp%" Pd, index);
   LocalVariable* variable = new (Z) LocalVariable(
-      TokenPosition::kNoSource, H.DartSymbol(name), Object::dynamic_type());
+      TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
+      H.DartSymbol(name),
+      Object::dynamic_type());
   // Set the index relative to the base of the expression stack including
   // outgoing arguments.
   variable->set_index(parsed_function_->first_stack_local_index() -
                       parsed_function_->num_stack_locals() -
                       pending_argument_count_ - index);
 
   // The value has uses as if it were a local variable.  Mark the definition
   // as used so that its temp index will not be cleared (causing it to never
   // be materialized in the expression stack).
   stack_->definition()->set_ssa_temp_index(0);
@@ skipping 240 matching lines @@
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     intptr_t parameter_count = dart_function.NumParameters();
     intptr_t parameter_index = parsed_function_->first_parameter_index();
     for (intptr_t i = 0; i < parameter_count; ++i, --parameter_index) {
       LocalVariable* variable = scope->VariableAt(i);
       if (variable->is_captured()) {
         // There is no LocalVariable describing the on-stack parameter so
         // create one directly.
         LocalVariable* parameter =
             new (Z) LocalVariable(TokenPosition::kNoSource,
-                                  Symbols::TempParam(), Object::dynamic_type());
+                                  TokenPosition::kNoSource,
+                                  Symbols::TempParam(),
+                                  Object::dynamic_type());
         parameter->set_index(parameter_index);
         // Mark the stack variable so it will be ignored by the code for
         // 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);
@@ skipping 2780 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart