Rename kDummyTokenIndex to kNoSourcePos

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1163 matching lines @@
   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(ident_pos, load_receiver, field);
 
   ReturnNode* return_node =
-      new ReturnNode(Scanner::kDummyTokenIndex, load_field);
+      new ReturnNode(Scanner::kNoSourcePos, 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);
@@ skipping 23 matching lines @@
 
   LoadLocalNode* receiver =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
   EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
   current_block_->statements->Add(store_field);
-  current_block_->statements->Add(new ReturnNode(Scanner::kDummyTokenIndex));
+  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
   const intptr_t ident_pos = func.token_pos();
-  const intptr_t invisible_pos = Scanner::kDummyTokenIndex;
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // 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(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
       Function::ZoneHandle(func.extracted_method_closure()),
       load_receiver,
       NULL);
 
-  ReturnNode* return_node = new ReturnNode(invisible_pos, closure);
+  ReturnNode* return_node = new ReturnNode(Scanner::kNoSourcePos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array& default_values) {
   ParamList params;
   // Receiver first.
@@ skipping 1144 matching lines @@
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const intptr_t ctor_pos = TokenPos();
-  const intptr_t dummy_pos = Scanner::kDummyTokenIndex;
   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
-      dummy_pos, Symbols::This(), *ReceiverType(current_class()));
+      Scanner::kNoSourcePos, Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->AddVariable(receiver);
 
-  LocalVariable* phase_parameter = new LocalVariable(
-      dummy_pos, Symbols::PhaseParameter(), Type::ZoneHandle(Type::SmiType()));
+  LocalVariable* phase_parameter =
+      new LocalVariable(Scanner::kNoSourcePos,
+                        Symbols::PhaseParameter(),
+                        Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // 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(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
@@ skipping 15 matching lines @@
     // whether optional parameters are even allowed in this situation.
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
       ErrorMsg(ctor_pos,
                "forwarding constructors must not have optional parameters");
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 2.
-    forwarding_args = new ArgumentListNode(dummy_pos);
+    forwarding_args = new ArgumentListNode(Scanner::kNoSourcePos);
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
-          dummy_pos,
+          Scanner::kNoSourcePos,
           String::ZoneHandle(func.ParameterNameAt(i)),
           Type::ZoneHandle(Type::DynamicType()));
       current_block_->scope->AddVariable(param);
-      forwarding_args->Add(new LoadLocalNode(dummy_pos, param));
+      forwarding_args->Add(new LoadLocalNode(Scanner::kNoSourcePos, param));
     }
   }
 
   GenerateSuperConstructorCall(current_class(),
-                               dummy_pos,
+                               Scanner::kNoSourcePos,
                                receiver,
                                forwarding_args);
   CheckFieldsInitialized(current_class());
 
   // Empty constructor body.
-  current_block_->statements->Add(new ReturnNode(dummy_pos));
+  current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(
           isolate()->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
@@ skipping 140 matching lines @@
 
   SequenceNode* init_statements = CloseBlock();
   if (is_redirecting_constructor) {
     // A redirecting super constructor simply passes the phase parameter on to
     // the target which executes the corresponding phase.
     current_block_->statements->Add(init_statements);
   } else if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
     AstNode* phase_value = new
-        LoadLocalNode(Scanner::kDummyTokenIndex, phase_param);
+        LoadLocalNode(Scanner::kNoSourcePos, phase_param);
     AstNode* phase_check = new BinaryOpNode(
-        Scanner::kDummyTokenIndex, Token::kBIT_AND, phase_value,
-        new LiteralNode(Scanner::kDummyTokenIndex,
+        Scanner::kNoSourcePos, Token::kBIT_AND, phase_value,
+        new LiteralNode(Scanner::kNoSourcePos,
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
-        new ComparisonNode(Scanner::kDummyTokenIndex,
+        new ComparisonNode(Scanner::kNoSourcePos,
                            Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(TokenPos(),
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_init_statements =
-        new IfNode(Scanner::kDummyTokenIndex,
+        new IfNode(Scanner::kNoSourcePos,
                    comparison,
                    init_statements,
                    NULL);
     current_block_->statements->Add(guarded_init_statements);
   }
 
   // Parsing of initializers done. Now we parse the constructor body
   // and add the implicit super call to the super constructor's body
   // if necessary.
   StaticCallNode* super_call = NULL;
@@ skipping 98 matching lines @@
     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(Scanner::kDummyTokenIndex, phase_param);
+        new LoadLocalNode(Scanner::kNoSourcePos, phase_param);
     AstNode* phase_check =
-        new BinaryOpNode(Scanner::kDummyTokenIndex, Token::kBIT_AND,
+        new BinaryOpNode(Scanner::kNoSourcePos, Token::kBIT_AND,
             phase_value,
-            new LiteralNode(Scanner::kDummyTokenIndex,
+            new LiteralNode(Scanner::kNoSourcePos,
                 Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
     AstNode* comparison =
-        new ComparisonNode(Scanner::kDummyTokenIndex,
+        new ComparisonNode(Scanner::kNoSourcePos,
                            Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(body_pos,
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_block_statements =
-        new IfNode(Scanner::kDummyTokenIndex, comparison, ctor_block, NULL);
+        new IfNode(Scanner::kNoSourcePos, comparison, ctor_block, NULL);
     current_block_->statements->Add(guarded_block_statements);
   }
   current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
@@ skipping 150 matching lines @@
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
-  const intptr_t dummy_pos = Scanner::kDummyTokenIndex;
   AstNode* argument =
-      new LoadLocalNode(dummy_pos,
+      new LoadLocalNode(Scanner::kNoSourcePos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
-      new LiteralNode(dummy_pos, Instance::ZoneHandle());
-  ComparisonNode* check_arg = new ComparisonNode(dummy_pos,
-                                                 Token::kEQ_STRICT,
-                                                 argument,
-                                                 null_operand);
-  ComparisonNode* result = new ComparisonNode(dummy_pos,
-                                              Token::kEQ_STRICT,
-                                              LoadReceiver(dummy_pos),
-                                              null_operand);
-  SequenceNode* arg_is_null = new SequenceNode(dummy_pos, NULL);
-  arg_is_null->Add(new ReturnNode(dummy_pos, result));
-  IfNode* if_arg_null = new IfNode(dummy_pos,
+      new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle());
+  ComparisonNode* check_arg =
+      new ComparisonNode(Scanner::kNoSourcePos,
+                         Token::kEQ_STRICT,
+                         argument,
+                         null_operand);
+  ComparisonNode* result =
+      new ComparisonNode(Scanner::kNoSourcePos,
+                         Token::kEQ_STRICT,
+                         LoadReceiver(Scanner::kNoSourcePos),
+                         null_operand);
+  SequenceNode* arg_is_null = new SequenceNode(Scanner::kNoSourcePos, NULL);
+  arg_is_null->Add(new ReturnNode(Scanner::kNoSourcePos, result));
+  IfNode* if_arg_null = new IfNode(Scanner::kNoSourcePos,
                                    check_arg,
                                    arg_is_null,
                                    NULL);
   current_block_->statements->Add(if_arg_null);
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
@@ skipping 7801 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart