Improve line info accuracy in debugging

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 741 matching lines @@
       break;
     case RawFunction::kConstImplicitGetter:
       node_sequence = parser.ParseStaticConstGetter(func);
       break;
     default:
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
-    node_sequence->Add(new ReturnNode(parser.TokenPos()));
+    node_sequence->Add(new ReturnNode(func.end_token_pos()));
   }
   if (parser.expression_temp_ != NULL) {
     parsed_function->set_expression_temp_var(parser.expression_temp_);
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
@@ skipping 27 matching lines @@
   TRACE_PARSER("ParseStaticConstGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
+  intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
 
   // Static const fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
 
   if (field.is_const()) {
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "initializer must be a compile-time constant");
     }
-    ReturnNode* return_node = new ReturnNode(TokenPos(), expr);
+    ReturnNode* return_node = new ReturnNode(ident_pos, expr);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
     // if (field.value === transition_sentinel) {
     //   field.value = null;
     //   throw("circular dependency in field initialization");
     // }
     // if (field.value === sentinel) {
     //   field.value = transition_sentinel;
     //   field.value = expr;
     // }
     // return field.value;  // Type check is executed here in checked mode.
 
     // Generate code checking for circular dependency in field initialization.
     AstNode* compare_circular = new ComparisonNode(
-        TokenPos(),
+        ident_pos,
         Token::kEQ_STRICT,
-        new LoadStaticFieldNode(TokenPos(), field),
-        new LiteralNode(TokenPos(), Object::transition_sentinel()));
+        new LoadStaticFieldNode(ident_pos, field),
+        new LiteralNode(ident_pos, Object::transition_sentinel()));
     // Set field to null prior to throwing exception, so that subsequent
     // accesses to the field do not throw again, since initializers should only
     // be executed once.
-    SequenceNode* report_circular = new SequenceNode(TokenPos(), NULL);
+    SequenceNode* report_circular = new SequenceNode(ident_pos, NULL);
     report_circular->Add(
         new StoreStaticFieldNode(
-            TokenPos(),
+            ident_pos,
             field,
-            new LiteralNode(TokenPos(), Instance::ZoneHandle())));
+            new LiteralNode(ident_pos, Instance::ZoneHandle())));
     // TODO(regis): Exception to throw is not specified by spec.
     const String& circular_error = String::ZoneHandle(
         Symbols::New("circular dependency in field initialization"));
     report_circular->Add(
-        new ThrowNode(TokenPos(),
-                      new LiteralNode(TokenPos(), circular_error),
+        new ThrowNode(ident_pos,
+                      new LiteralNode(ident_pos, circular_error),
                       NULL));
     AstNode* circular_check =
-        new IfNode(TokenPos(), compare_circular, report_circular, NULL);
+        new IfNode(ident_pos, compare_circular, report_circular, NULL);
     current_block_->statements->Add(circular_check);
 
     // Generate code checking for uninitialized field.
     AstNode* compare_uninitialized = new ComparisonNode(
-        TokenPos(),
+        ident_pos,
         Token::kEQ_STRICT,
-        new LoadStaticFieldNode(TokenPos(), field),
-        new LiteralNode(TokenPos(), Object::sentinel()));
-    SequenceNode* initialize_field = new SequenceNode(TokenPos(), NULL);
+        new LoadStaticFieldNode(ident_pos, field),
+        new LiteralNode(ident_pos, Object::sentinel()));
+    SequenceNode* initialize_field = new SequenceNode(ident_pos, NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
-            TokenPos(),
+            ident_pos,
             field,
-            new LiteralNode(
-                TokenPos(), Object::transition_sentinel())));
+            new LiteralNode(ident_pos, Object::transition_sentinel())));
     // TODO(hausner): If evaluation of the field value throws an exception,
     // we leave the field value as 'transition_sentinel', which is wrong.
     // A second reference to the field later throws a circular dependency
     // exception. The field should instead be set to null after an exception.
-    initialize_field->Add(new StoreStaticFieldNode(TokenPos(), field, expr));
+    initialize_field->Add(new StoreStaticFieldNode(ident_pos, field, expr));
     AstNode* uninitialized_check =
-        new IfNode(TokenPos(), compare_uninitialized, initialize_field, NULL);
+        new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
-        new ReturnNode(TokenPos(),
-                       new LoadStaticFieldNode(TokenPos(), field));
+        new ReturnNode(ident_pos,
+                       new LoadStaticFieldNode(ident_pos, field));
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
+  // func.token_pos() points to the name of the field.
+  intptr_t ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
-  params.AddReceiver(ReceiverType(TokenPos()));
+  params.AddReceiver(ReceiverType(ident_pos));
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
-  LoadLocalNode* load_receiver = new LoadLocalNode(TokenPos(), receiver);
-  // TokenPos() returns the function's token position which points to the
-  // name of the field;
+  LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
-      new LoadInstanceFieldNode(TokenPos(), load_receiver, field);
+      new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
-  ReturnNode* return_node = new ReturnNode(TokenPos(), load_field);
+  ReturnNode* return_node = new ReturnNode(ident_pos, load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
-  // TokenPos() returns the function's token position which points to
-  // the name of the field; we can use it to form the field_name.
+  // func.token_pos() points to the name of the field.
+  intptr_t ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::ZoneHandle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
-  params.AddReceiver(ReceiverType(TokenPos()));
-  params.AddFinalParameter(TokenPos(),
+  params.AddReceiver(ReceiverType(ident_pos));
+  params.AddFinalParameter(ident_pos,
                            &String::ZoneHandle(Symbols::Value()),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
-      new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(0));
+      new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
-      new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(1));
+      new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
   StoreInstanceFieldNode* store_field =
-      new StoreInstanceFieldNode(TokenPos(), receiver, field, value);
+      new StoreInstanceFieldNode(ident_pos, receiver, field, value);
 
   current_block_->statements->Add(store_field);
-  current_block_->statements->Add(new ReturnNode(TokenPos()));
+  current_block_->statements->Add(new ReturnNode(ident_pos));
   return CloseBlock();
 }
 
 
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   GrowableArray<Token::Kind> token_stack(8);
   const intptr_t block_start_pos = TokenPos();
   bool is_match = true;
   bool unexpected_token_found = false;
@@ skipping 1604 matching lines @@
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
     } else {
       ConsumeToken();
       SkipExpr();
       ExpectSemicolon();
     }
-    method_end_pos = TokenPos();
+    method_end_pos = TokenPos() - 1;
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor or factory '%s' may not be native",
                method->name->ToCString());
     }
@@ skipping 1173 matching lines @@
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   intptr_t function_end_pos = function_pos;
   if (is_external) {
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
-    function_end_pos = TokenPos();
+    function_end_pos = TokenPos() - 1;
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
-    function_end_pos = TokenPos();
+    function_end_pos = TokenPos() - 1;
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(func_name,
                     RawFunction::kRegularFunction,
                     is_static,
                     /* is_const = */ false,
@@ skipping 1011 matching lines @@
     if (!current_block_->scope->AddVariable(function_variable)) {
       ErrorMsg(ident_pos, "identifier '%s' already defined",
                function_variable->name().ToCString());
     }
   }
 
   // Parse the local function.
   Array& default_parameter_values = Array::Handle();
   SequenceNode* statements = Parser::ParseFunc(function,
                                                default_parameter_values);
-  ASSERT(is_new_closure || (function.end_token_pos() == TokenPos()));
-  function.set_end_token_pos(TokenPos());
+  ASSERT(is_new_closure || (function.end_token_pos() == (TokenPos() - 1)));
+  function.set_end_token_pos(TokenPos() - 1);
 
   // Now that the local function has formal parameters, lookup the signature
   // class in the current library (but not in its imports) and only create a new
   // canonical signature class if it does not exist yet.
   const String& signature = String::Handle(function.Signature());
   Class& signature_class = Class::ZoneHandle();
   if (!is_new_closure) {
     signature_class = function.signature_class();
   }
   if (signature_class.IsNull()) {
@@ skipping 4860 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart