Generate better debugging info for actor phase check

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 2331 matching lines @@
       AstNode* arg = ctor_args->NodeAt(i);
       if (!IsSimpleLocalOrLiteralNode(arg)) {
         LocalVariable* temp =
             CreateTempConstVariable(arg->token_pos(), "sca");
         AstNode* save_temp = new StoreLocalNode(arg->token_pos(), temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
+  intptr_t body_pos = TokenPos();
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
     ArgumentListNode* initializer_args = super_call->arguments();
     const Function& super_ctor = super_call->function();
     // Patch the initializer call so it only executes the super initializer.
     initializer_args->SetNodeAt(1,
-        new LiteralNode(TokenPos(),
+        new LiteralNode(body_pos,
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
 
-    ArgumentListNode* super_call_args = new ArgumentListNode(TokenPos());
+    ArgumentListNode* super_call_args = new ArgumentListNode(body_pos);
     // First argument is the receiver.
-    super_call_args->Add(new LoadLocalNode(TokenPos(), receiver));
+    super_call_args->Add(new LoadLocalNode(body_pos, receiver));
     // Second argument is the construction phase argument.
     AstNode* phase_parameter =
-        new LiteralNode(TokenPos(),
+        new LiteralNode(body_pos,
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
     super_call_args->Add(phase_parameter);
     super_call_args->set_names(initializer_args->names());
     for (int i = 2; i < initializer_args->length(); i++) {
       AstNode* arg = initializer_args->NodeAt(i);
       if (arg->IsLiteralNode()) {
         LiteralNode* lit = arg->AsLiteralNode();
-        super_call_args->Add(new LiteralNode(TokenPos(), lit->literal()));
+        super_call_args->Add(new LiteralNode(body_pos, lit->literal()));
       } else {
         ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
         if (arg->IsLoadLocalNode()) {
           const LocalVariable& temp = arg->AsLoadLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(TokenPos(), &temp));
+          super_call_args->Add(new LoadLocalNode(body_pos, &temp));
         } else if (arg->IsStoreLocalNode()) {
           const LocalVariable& temp = arg->AsStoreLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(TokenPos(), &temp));
+          super_call_args->Add(new LoadLocalNode(body_pos, &temp));
         }
       }
     }
     ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
                                         super_call_args->names(),
                                         NULL));
     current_block_->statements->Add(
-        new StaticCallNode(TokenPos(), super_ctor, super_call_args));
+        new StaticCallNode(body_pos, super_ctor, super_call_args));
   }
 
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ErrorMsg("constructors may not return a value");
   } else if (IsLiteral("native")) {
     ErrorMsg("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
     // Generate guard around the constructor body code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(TokenPos(), phase_param);
+    AstNode* phase_value = new LoadLocalNode(body_pos, phase_param);
     AstNode* phase_check =
-        new BinaryOpNode(TokenPos(), Token::kBIT_AND,
+        new BinaryOpNode(body_pos, Token::kBIT_AND,
             phase_value,
-            new LiteralNode(TokenPos(),
+            new LiteralNode(body_pos,
                 Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
     AstNode* comparison =
-       new ComparisonNode(TokenPos(), Token::kNE_STRICT,
+       new ComparisonNode(body_pos, Token::kNE_STRICT,
                          phase_check,
-                         new LiteralNode(TokenPos(),
+                         new LiteralNode(body_pos,
                                          Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_block_statements =
-        new IfNode(TokenPos(), comparison, ctor_block, NULL);
+        new IfNode(body_pos, comparison, ctor_block, NULL);
     current_block_->statements->Add(guarded_block_statements);
   }
 
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
@@ skipping 2437 matching lines @@
   return from_scope->LookupVariable(Symbols::This(), test_only);
 }
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
                                                     bool test_only) {
   ASSERT(current_function().IsInFactoryScope());
   return from_scope->LookupVariable(Symbols::TypeArgumentsParameter(),
                                     test_only);
 }
+
+
 LocalVariable* Parser::LookupPhaseParameter() {
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(Symbols::PhaseParameter(),
                                                kTestOnly);
 }
 
 
 void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
@@ skipping 5083 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart