Add local variable declaration token position to service protocol

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 212 matching lines @@
                    String::Handle(function_.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   if (!has_expression_temp_var()) {
     LocalVariable* temp =
         new (Z) LocalVariable(function_.token_pos(),
+                              function_.token_pos(),
                               Symbols::ExprTemp(),
                               Object::dynamic_type());
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
 
 void ParsedFunction::EnsureFinallyReturnTemp(bool is_async) {
   if (!has_finally_return_temp_var()) {
     LocalVariable* temp = new(Z) LocalVariable(
         function_.token_pos(),
+        function_.token_pos(),
         Symbols::FinallyRetVal(),
         Object::dynamic_type());
     ASSERT(temp != NULL);
     temp->set_is_final();
     if (is_async) {
       temp->set_is_captured();
     }
     set_finally_return_temp_var(temp);
   }
   ASSERT(has_finally_return_temp_var());
@@ skipping 2857 matching lines @@
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsGenerativeConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const TokenPosition ctor_pos = TokenPos();
   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::This(),
       *ReceiverType(current_class()));
   current_block_->scope->InsertParameterAt(0, receiver);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(
@@ skipping 28 matching lines @@
                   "constructor of the class extending the mixin application",
                   String::Handle(Z, super_class.Name()).ToCString());
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 1.
     forwarding_args = new ArgumentListNode(ST(ctor_pos));
     for (int i = 1; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           TokenPosition::kNoSource,
+          TokenPosition::kNoSource,
           String::ZoneHandle(Z, func.ParameterNameAt(i)),
           Object::dynamic_type());
       current_block_->scope->InsertParameterAt(i, param);
       forwarding_args->Add(new LoadLocalNode(ST(ctor_pos), param));
     }
   }
 
   AstNode* super_call = GenerateSuperConstructorCall(
       current_class(),
       ctor_pos,
@@ skipping 3896 matching lines @@
   return closure.raw();
 }
 
 
 void Parser::AddContinuationVariables() {
   // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   LocalVariable* await_jump_var = new (Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AwaitJumpVar(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(await_jump_var);
   LocalVariable* await_ctx_var = new (Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AwaitContextVar(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(await_ctx_var);
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to current block's scope:
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_completer;
   LocalVariable* async_op_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncOperation(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncThenCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncCatchErrorCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
   LocalVariable* async_completer = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncCompleter(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_completer);
 }
 
 
 void Parser::AddAsyncGeneratorVariables() {
   // Add to current block's scope:
   //   var :controller;
   // The :controller variable is used by the async generator closure to
   // store the StreamController object to which the yielded expressions
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   // These variables are used to store the async generator closure containing
   // the body of the async* function. They are used by the await operator.
   LocalVariable* controller_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::Controller(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(controller_var);
   LocalVariable* async_op_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncOperation(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncThenCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new(Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       Symbols::AsyncCatchErrorCallback(),
       Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
 }
 
 
 RawFunction* Parser::OpenAsyncGeneratorFunction(
     TokenPosition async_func_pos) {
   TRACE_PARSER("OpenAsyncGeneratorFunction");
   AddContinuationVariables();
@@ skipping 468 matching lines @@
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
     LocalVariable* parameter = new(Z) LocalVariable(
-        param_desc.name_pos, *name, *param_desc.type);
+        param_desc.name_pos,
+        param_desc.name_pos,
+        *name,
+        *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
       ReportError(param_desc.name_pos,
                   "name '%s' already exists in scope",
                   param_desc.name->ToCString());
     }
     param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
     if (FLAG_initializing_formal_access) {
@@ skipping 91 matching lines @@
   const TokenPosition assign_pos = TokenPos();
   AstNode* initialization = NULL;
   LocalVariable* variable = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     ConsumeToken();
     AstNode* expr = ParseAwaitableExpr(
         is_const, kConsumeCascades, await_preamble);
     const TokenPosition expr_end_pos = TokenPos();
     variable = new(Z) LocalVariable(
-        expr_end_pos, ident, type);
+        ident_pos,
+        expr_end_pos,
+        ident,
+        type);
     initialization = new(Z) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ReportError(ident_pos,
                 "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     variable = new(Z) LocalVariable(
-        assign_pos, ident, type);
+        ident_pos,
+        assign_pos,
+        ident,
+        type);
     AstNode* null_expr = new(Z) LiteralNode(ident_pos, Object::null_instance());
     initialization = new(Z) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
   const TokenPosition previous_pos =
       current_block_->scope->PreviousReferencePos(ident);
   if (previous_pos.IsReal()) {
     ASSERT(!script_.IsNull());
@@ skipping 116 matching lines @@
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle(Z);
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
 
   const TokenPosition function_pos = TokenPos();
+  TokenPosition function_name_pos = TokenPosition::kNoSource;
   TokenPosition metadata_pos = TokenPosition::kNoSource;
   if (is_literal) {
     ASSERT(CurrentToken() == Token::kLPAREN || CurrentToken() == Token::kLT);
     function_name = &Symbols::AnonymousClosure();
   } else {
     metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else if (IsFunctionReturnType()) {
       // It is too early to resolve the type here, since it can be a result type
       // referring to a not yet declared function type parameter.
       result_type = ParseType(ClassFinalizer::kDoNotResolve);
     }
-    const TokenPosition name_pos = TokenPos();
+    function_name_pos = TokenPos();
     variable_name = ExpectIdentifier("function name expected");
     function_name = variable_name;
 
     // Check that the function name has not been referenced
     // before this declaration.
     ASSERT(current_block_ != NULL);
     const TokenPosition previous_pos =
         current_block_->scope->PreviousReferencePos(*function_name);
     if (previous_pos.IsReal()) {
       ASSERT(!script_.IsNull());
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
-      ReportError(name_pos,
+      ReportError(function_name_pos,
                   "identifier '%s' previously used in line %" Pd "",
                   function_name->ToCString(),
                   line_number);
     }
   }
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
@@ skipping 58 matching lines @@
     const Class& unknown_scope_class = Class::Handle(Z,
         I->object_store()->closure_class());
     function_type = Type::New(unknown_scope_class,
                               TypeArguments::Handle(Z),
                               function_pos);
     function_type.set_signature(function);
     function_type.SetIsFinalized();  // No finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
-    function_variable = new(Z) LocalVariable(function_pos,
+    function_variable = new(Z) LocalVariable(function_name_pos,
+                                             function_pos,
                                              *variable_name,
                                              function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
@@ skipping 791 matching lines @@
   // variable is set to dynamic. It will later be patched to match the
   // type of the case clause expressions. Therefore, we have to allocate
   // a new type representing dynamic and can't reuse the canonical
   // type object for dynamic.
   const Type& temp_var_type = Type::ZoneHandle(Z,
        Type::New(Class::Handle(Z, Object::dynamic_class()),
                  TypeArguments::Handle(Z),
                  expr_pos));
   temp_var_type.SetIsFinalized();
   LocalVariable* temp_variable = new(Z) LocalVariable(
-      expr_pos,  Symbols::SwitchExpr(), temp_var_type);
+      expr_pos, expr_pos,  Symbols::SwitchExpr(), temp_var_type);
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr = new(Z) StoreLocalNode(
       expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   GrowableArray<LiteralNode*> case_expr_values;
   while (true) {
     // Check for statement label
@@ skipping 269 matching lines @@
   ASSERT(!iterator_ctor.IsNull());
   ArgumentListNode* ctor_args = new (Z) ArgumentListNode(stream_expr_pos);
   ctor_args->Add(stream_expr);
   ConstructorCallNode* ctor_call =
       new (Z) ConstructorCallNode(stream_expr_pos,
                               TypeArguments::ZoneHandle(Z),
                               iterator_ctor,
                               ctor_args);
   const AbstractType& iterator_type = Object::dynamic_type();
   LocalVariable* iterator_var = new(Z) LocalVariable(
-      stream_expr_pos, Symbols::ForInIter(), iterator_type);
+      stream_expr_pos, stream_expr_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
   AstNode* iterator_init =
       new(Z) StoreLocalNode(stream_expr_pos, iterator_var, ctor_call);
   current_block_->statements->Add(iterator_init);
 
   // We need to ensure that the stream is cancelled after the loop.
   // Thus, wrap the loop in a try-finally that calls :for-in-iter.close()
   // in the finally clause. It is harmless to call close() if the stream
   // is already cancelled (when moveNext() returns false).
   // Note: even though this is async code, we do not need to set up
@@ skipping 64 matching lines @@
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (new_loop_var) {
     // The for loop variable is new for each iteration.
     // Create a variable and add it to the loop body scope.
     // Note that the variable token position needs to be inside the
     // loop block, so it gets put in the loop context level.
     LocalVariable* loop_var =
         new(Z) LocalVariable(loop_var_assignment_pos,
+                             loop_var_assignment_pos,
                              *loop_var_name,
                              loop_var_type);;
     if (loop_var_is_final) {
       loop_var->set_is_final();
     }
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment = new(Z) StoreLocalNode(
         loop_var_assignment_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
@@ skipping 155 matching lines @@
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     // Delay creation of the local variable until we know its actual
     // position, which is inside the loop body.
     new_loop_var = true;
     loop_var_type = ParseConstFinalVarOrType(
         I->type_checks() ? ClassFinalizer::kCanonicalize :
                                    ClassFinalizer::kIgnore);
+    loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   }
   ExpectToken(Token::kIN);
 
   // Ensure that the block token range contains the call to moveNext and it
   // also starts the block at a different token position than the following
   // loop block. Both blocks can allocate contexts and if they have a matching
   // token position range, it can be an issue (cf. bug 26941).
   OpenBlock();  // Implicit block around while loop.
 
   const TokenPosition collection_pos = TokenPos();
   AstNode* collection_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
   // Generate implicit iterator variable and add to scope.
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
   const AbstractType& iterator_type = Object::dynamic_type();
   LocalVariable* iterator_var = new(Z) LocalVariable(
+      collection_pos,
       collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   ArgumentListNode* no_args = new(Z) ArgumentListNode(collection_pos);
   AstNode* get_iterator = new(Z) InstanceGetterNode(
       collection_pos, collection_expr, Symbols::Iterator());
   AstNode* iterator_init =
       new(Z) StoreLocalNode(collection_pos, iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
@@ skipping 17 matching lines @@
       loop_var_assignment_pos,
       new(Z) LoadLocalNode(loop_var_assignment_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (new_loop_var) {
     // The for loop variable is new for each iteration.
     // Create a variable and add it to the loop body scope.
     LocalVariable* loop_var =
-       new(Z) LocalVariable(loop_var_assignment_pos,
+       new(Z) LocalVariable(loop_var_pos,
+                            loop_var_assignment_pos,
                             *loop_var_name,
                             loop_var_type);;
     if (loop_var_is_final) {
       loop_var->set_is_final();
     }
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment = new(Z) StoreLocalNode(
         loop_var_assignment_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
@@ skipping 146 matching lines @@
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(CatchParamDesc* exception_param,
                                    CatchParamDesc* stack_trace_param,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
     LocalVariable* var = new(Z) LocalVariable(
         exception_param->token_pos,
+        exception_param->token_pos,
         *exception_param->name,
         *exception_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     ASSERT(added_to_scope);
     exception_param->var = var;
   }
   if (stack_trace_param->name != NULL) {
     LocalVariable* var = new(Z) LocalVariable(
         stack_trace_param->token_pos,
+        stack_trace_param->token_pos,
         *stack_trace_param->name,
         *stack_trace_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
       // The name of the exception param is reused for the stack trace param.
       ReportError(stack_trace_param->token_pos,
                   "name '%s' already exists in scope",
                   stack_trace_param->name->ToCString());
     }
@@ skipping 389 matching lines @@
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name = String::ZoneHandle(Z,
       Symbols::NewFormatted(T,
                             "%s%d",
                             Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
                             last_used_try_index_ - 1));
   LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
       TokenPosition::kNoSource,
+      TokenPosition::kNoSource,
       async_saved_try_ctx_name,
       Object::dynamic_type());
   ASSERT(async_temp_scope_ != NULL);
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       TokenPosition::kNoSource,
       async_saved_try_ctx,
       new(Z) LoadLocalNode(TokenPosition::kNoSource, saved_try_context)));
 }
@@ skipping 21 matching lines @@
                                      LocalVariable** context_var,
                                      LocalVariable** exception_var,
                                      LocalVariable** stack_trace_var,
                                      LocalVariable** saved_exception_var,
                                      LocalVariable** saved_stack_trace_var) {
   // Consecutive try statements share the same set of variables.
   *context_var = try_scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (*context_var == NULL) {
     *context_var = new(Z) LocalVariable(
         TokenPos(),
+        TokenPos(),
         Symbols::SavedTryContextVar(),
         Object::dynamic_type());
     try_scope->AddVariable(*context_var);
   }
   *exception_var = try_scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (*exception_var == NULL) {
     *exception_var = new(Z) LocalVariable(
         TokenPos(),
+        TokenPos(),
         Symbols::ExceptionVar(),
         Object::dynamic_type());
     try_scope->AddVariable(*exception_var);
   }
   *stack_trace_var = try_scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (*stack_trace_var == NULL) {
     *stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
+        TokenPos(),
         Symbols::StackTraceVar(),
         Object::dynamic_type());
     try_scope->AddVariable(*stack_trace_var);
   }
   if (is_async) {
     *saved_exception_var = try_scope->LocalLookupVariable(
         Symbols::SavedExceptionVar());
     if (*saved_exception_var == NULL) {
       *saved_exception_var = new(Z) LocalVariable(
           TokenPos(),
+          TokenPos(),
           Symbols::SavedExceptionVar(),
           Object::dynamic_type());
       try_scope->AddVariable(*saved_exception_var);
     }
     *saved_stack_trace_var = try_scope->LocalLookupVariable(
         Symbols::SavedStackTraceVar());
     if (*saved_stack_trace_var == NULL) {
       *saved_stack_trace_var = new(Z) LocalVariable(
           TokenPos(),
+          TokenPos(),
           Symbols::SavedStackTraceVar(),
           Object::dynamic_type());
       try_scope->AddVariable(*saved_stack_trace_var);
     }
   }
 }
 
 
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
@@ skipping 960 matching lines @@
   parsed_function()->EnsureExpressionTemp();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(TokenPosition token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd "", s, token_pos.value());
   LocalVariable* temp = new(Z) LocalVariable(
       token_pos,
+      token_pos,
       String::ZoneHandle(Z, Symbols::New(T, name)),
       Object::dynamic_type());
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 AstNode* Parser::OptimizeBinaryOpNode(TokenPosition op_pos,
                                       Token::Kind binary_op,
@@ skipping 3999 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