Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

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 62 matching lines @@
  private:
   void PrintIndent() {
     for (int i = 0; i < indent_; i++) { OS::Print(". "); }
   }
   static int indent_;
 };
 
 int TraceParser::indent_ = 0;
 
 #define TRACE_PARSER(s) \
-  TraceParser __p__(this->token_index_, this->script_, s)
+  TraceParser __p__(this->TokenIndex(), this->script_, s)
 
 #else  // not DEBUG
 #define TRACE_PARSER(s)
 #endif  // DEBUG
 
 
 static RawTypeArguments* NewTypeArguments(const GrowableObjectArray& objs) {
   const TypeArguments& a =
       TypeArguments::Handle(TypeArguments::New(objs.Length()));
   AbstractType& type = AbstractType::Handle();
@@ skipping 95 matching lines @@
     scope->AddVariable(context_var);
     set_saved_context_var(context_var);
   }
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   stack_local_count_ = first_stack_local_index_ - next_free_frame_index;
 }
 
 
+bool TokenStreamIterator::IsNull() const {
+  return tokens_.IsNull();
+}
+
+
+Token::Kind TokenStreamIterator::CurrentTokenKind() const {
+  return tokens_.KindAt(token_index_);
+}
+
+
+Token::Kind TokenStreamIterator::LookaheadTokenKind(intptr_t num_tokens) const {
+  return tokens_.KindAt(token_index_ + num_tokens);
+}
+
+
+RawObject* TokenStreamIterator::CurrentToken() const {
+  return tokens_.TokenAt(token_index_);
+}
+
+
+RawString* TokenStreamIterator::CurrentLiteral() const {
+  return tokens_.LiteralAt(token_index_);
+}
+
+
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
     : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
@@ skipping 31 matching lines @@
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script,
                const Library& library)
     : script_(script),
-      tokens_(TokenStream::Handle(script.tokens())),
-      token_index_(0),
+      tokens_iterator_(TokenStream::Handle(script.tokens()), 0),
+      token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(Function::Handle()),
       current_class_(Class::Handle()),
       library_(library),
       try_blocks_list_(NULL),
       expression_temp_(NULL) {
-  ASSERT(!tokens_.IsNull());
+  ASSERT(!tokens_iterator_.IsNull());
   ASSERT(!library.IsNull());
-  SetPosition(0);
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                const Function& function,
                intptr_t token_index)
     : script_(script),
-      tokens_(TokenStream::Handle(script.tokens())),
-      token_index_(0),
+      tokens_iterator_(TokenStream::Handle(script.tokens()), token_index),
+      token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
       current_class_(Class::Handle(current_function_.owner())),
       library_(Library::Handle(current_class_.library())),
       try_blocks_list_(NULL),
       expression_temp_(NULL)  {
-  ASSERT(!tokens_.IsNull());
+  ASSERT(!tokens_iterator_.IsNull());
   ASSERT(!function.IsNull());
-  SetPosition(token_index);
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
 }
 
 
 const Function& Parser::current_function() const {
   return current_function_;
 }
 
 
 const Class& Parser::current_class() const {
   return current_class_;
 }
 
 
 void Parser::set_current_class(const Class& value) {
   current_class_ = value.raw();
 }
 
 
 void Parser::SetPosition(intptr_t position) {
-  if (position < token_index_ && position != 0) {
-    CompilerStats::num_tokens_rewind += (token_index_ - position);
+  if (position < TokenIndex() && position != 0) {
+    CompilerStats::num_tokens_rewind += (TokenIndex() - position);
   }
-  token_index_ = position;
+  tokens_iterator_.SetCurrentIndex(position);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   ASSERT(Isolate::Current()->long_jump_base()->IsSafeToJump());
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Parser parser(script, library);
   parser.ParseTopLevel();
   if (FLAG_compiler_stats) {
-    CompilerStats::num_tokens_total += parser.tokens_.Length();

[hausner, 2012/06/22 00:02:27]

The number of tokens will not be equivalent to the length of the token stream. 

[siva, 2012/06/22 17:59:02]

Changed name Length() to NumberOfTokens() in the stream.

On 2012/06/22 00:02:27, hausner wrote:

+    CompilerStats::num_tokens_total += parser.tokens_iterator_.Length();
   }
 }
 
 
 Token::Kind Parser::CurrentToken() {
   if (token_kind_ == Token::kILLEGAL) {
-    token_kind_ = tokens_.KindAt(token_index_);
+    token_kind_ = tokens_iterator_.CurrentTokenKind();
     if (token_kind_ == Token::kERROR) {
-      ErrorMsg(token_index_, CurrentLiteral()->ToCString());
+      ErrorMsg(TokenIndex(), CurrentLiteral()->ToCString());
     }
   }
   CompilerStats::num_token_checks++;
   return token_kind_;
 }
 
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
-  return tokens_.KindAt(token_index_ + num_tokens);
+  return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
 
 String* Parser::CurrentLiteral() const {
   String& result = String::ZoneHandle();
-  result ^= tokens_.LiteralAt(token_index_);
+  result ^= tokens_iterator_.CurrentLiteral();
   return &result;
 }
 
 
 RawDouble* Parser::CurrentDoubleLiteral() const {
   LiteralToken& token = LiteralToken::Handle();
-  token ^= tokens_.TokenAt(token_index_);
+  token ^= tokens_iterator_.CurrentToken();
   ASSERT(token.kind() == Token::kDOUBLE);
   return reinterpret_cast<RawDouble*>(token.value());
 }
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
   LiteralToken& token = LiteralToken::Handle();
-  token ^= tokens_.TokenAt(token_index_);
+  token ^= tokens_iterator_.CurrentToken();
   ASSERT(token.kind() == Token::kINTEGER);
   return reinterpret_cast<RawInteger*>(token.value());
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
   }
@@ skipping 315 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.token_index_));
+    node_sequence->Add(new ReturnNode(parser.TokenIndex()));
   }
   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 39 matching lines @@
       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 = token_index_;
+  const intptr_t expr_pos = TokenIndex();
   AstNode* expr = ParseExpr(kAllowConst);
   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(token_index_, expr);
+    ReturnNode* return_node = new ReturnNode(TokenIndex(), 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.
 
     // TODO(regis): Remove this check once we support proper const fields.
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "initializer must be a compile time constant");
     }
 
     // Generate code checking for circular dependency in field initialization.
     AstNode* compare_circular = new ComparisonNode(
-        token_index_,
+        TokenIndex(),
         Token::kEQ_STRICT,
-        new LoadStaticFieldNode(token_index_, field),
-        new LiteralNode(token_index_,
+        new LoadStaticFieldNode(TokenIndex(), field),
+        new LiteralNode(TokenIndex(),
                         Instance::ZoneHandle(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(token_index_, NULL);
+    SequenceNode* report_circular = new SequenceNode(TokenIndex(), NULL);
     report_circular->Add(
         new StoreStaticFieldNode(
-            token_index_,
+            TokenIndex(),
             field,
-            new LiteralNode(token_index_, Instance::ZoneHandle())));
+            new LiteralNode(TokenIndex(), Instance::ZoneHandle())));
     // TODO(regis): Exception to throw is not specified by spec.
     const String& circular_error = String::ZoneHandle(
         String::NewSymbol("circular dependency in field initialization"));
     report_circular->Add(
-        new ThrowNode(token_index_,
-                      new LiteralNode(token_index_, circular_error),
+        new ThrowNode(TokenIndex(),
+                      new LiteralNode(TokenIndex(), circular_error),
                       NULL));
     AstNode* circular_check =
-        new IfNode(token_index_, compare_circular, report_circular, NULL);
+        new IfNode(TokenIndex(), compare_circular, report_circular, NULL);
     current_block_->statements->Add(circular_check);
 
     // Generate code checking for uninitialized field.
     AstNode* compare_uninitialized = new ComparisonNode(
-        token_index_,
+        TokenIndex(),
         Token::kEQ_STRICT,
-        new LoadStaticFieldNode(token_index_, field),
-        new LiteralNode(token_index_,
+        new LoadStaticFieldNode(TokenIndex(), field),
+        new LiteralNode(TokenIndex(),
                         Instance::ZoneHandle(Object::sentinel())));
-    SequenceNode* initialize_field = new SequenceNode(token_index_, NULL);
+    SequenceNode* initialize_field = new SequenceNode(TokenIndex(), NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
-            token_index_,
+            TokenIndex(),
             field,
             new LiteralNode(
-                token_index_,
+                TokenIndex(),
                 Instance::ZoneHandle(Object::transition_sentinel()))));
-    initialize_field->Add(new StoreStaticFieldNode(token_index_, field, expr));
+    initialize_field->Add(new StoreStaticFieldNode(TokenIndex(), field, expr));
     AstNode* uninitialized_check =
-        new IfNode(token_index_, compare_uninitialized, initialize_field, NULL);
+        new IfNode(TokenIndex(), compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
-        new ReturnNode(token_index_,
-                       new LoadStaticFieldNode(token_index_, field));
+        new ReturnNode(TokenIndex(),
+                       new LoadStaticFieldNode(TokenIndex(), 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;
-  params.AddReceiver(token_index_);
+  params.AddReceiver(TokenIndex());
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(func.num_optional_parameters() == 0);
   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(token_index_, *receiver);
-  // token_index_ is the function's token position which points to the name of
-  // the field;
+  LoadLocalNode* load_receiver = new LoadLocalNode(TokenIndex(), *receiver);
+  // TokenIndex() returns the function's token position which points to the
+  // name of the field;
   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(token_index_, load_receiver, field);
+      new LoadInstanceFieldNode(TokenIndex(), load_receiver, field);
 
-  ReturnNode* return_node = new ReturnNode(token_index_, load_field);
+  ReturnNode* return_node = new ReturnNode(TokenIndex(), 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");
-  // token_index_ is the function's token position which points to the name of
-  // the field; we can use it to form the field_name.
+  // TokenIndex() returns the function's token position which points to
+  // the name of the field; we can use it to form the field_name.
   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;
-  params.AddReceiver(token_index_);
-  params.AddFinalParameter(token_index_, "value", &field_type);
+  params.AddReceiver(TokenIndex());
+  params.AddFinalParameter(TokenIndex(), "value", &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(func.num_optional_parameters() == 0);
   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(token_index_, *current_block_->scope->VariableAt(0));
+      new LoadLocalNode(TokenIndex(), *current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
-      new LoadLocalNode(token_index_, *current_block_->scope->VariableAt(1));
+      new LoadLocalNode(TokenIndex(), *current_block_->scope->VariableAt(1));
 
   StoreInstanceFieldNode* store_field =
-      new StoreInstanceFieldNode(token_index_, receiver, field, value);
+      new StoreInstanceFieldNode(TokenIndex(), receiver, field, value);
 
   current_block_->statements->Add(store_field);
-  current_block_->statements->Add(new ReturnNode(token_index_));
+  current_block_->statements->Add(new ReturnNode(TokenIndex()));
   return CloseBlock();
 }
 
 
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   GrowableArray<Token::Kind> token_stack(8);
-  const intptr_t block_start_pos = token_index_;
+  const intptr_t block_start_pos = TokenIndex();
   bool is_match = true;
   bool unexpected_token_found = false;
   Token::Kind token;
   intptr_t token_index;
   do {
     token = CurrentToken();
-    token_index = token_index_;
+    token_index = TokenIndex();
     switch (token) {
       case Token::kLBRACE:
       case Token::kLPAREN:
       case Token::kLBRACK:
         token_stack.Add(token);
         break;
       case Token::kRBRACE:
         is_match = token_stack.Last() == Token::kLBRACE;
         token_stack.RemoveLast();
         break;
@@ skipping 80 matching lines @@
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
 
   // At this point, we must see an identifier for the parameter name.
-  parameter.name_pos = token_index_;
+  parameter.name_pos = TokenIndex();
   parameter.name = ExpectIdentifier("parameter name expected");
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
   // Check for duplicate formal parameters.
   const intptr_t num_existing_parameters =
       params->num_fixed_parameters + params->num_optional_parameters;
   for (intptr_t i = 0; i < num_existing_parameters; i++) {
     ParamDesc& existing_parameter = (*params->parameters)[i];
@@ skipping 233 matching lines @@
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
-  const intptr_t supercall_pos = token_index_;
+  const intptr_t supercall_pos = TokenIndex();
 
   bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(
       GetSuperFunction(supercall_pos, function_name, &is_no_such_method));
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super call.
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
@@ skipping 12 matching lines @@
   if (node->IsLoadLocalNode() && !node->AsLoadLocalNode()->HasPseudo()) {
     return true;
   }
   return false;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
-  const intptr_t operator_pos = token_index_;
+  const intptr_t operator_pos = TokenIndex();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst);
     ExpectToken(Token::kRBRACK);
 
     if (Token::IsAssignmentOperator(CurrentToken()) &&
         (CurrentToken() != Token::kASSIGN)) {
       // Compound assignment. Ensure side effects in index expression
       // only execute once. If the index is not a local variable or an
@@ skipping 104 matching lines @@
         CaptureReceiver();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
   TRACE_PARSER("ParseSuperFieldAccess");
-  const intptr_t field_pos = token_index_;
+  const intptr_t field_pos = TokenIndex();
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Field::GetterName(field_name));
   const Function& super_getter = Function::ZoneHandle(
@@ skipping 42 matching lines @@
     setter_arguments->Add(implicit_argument);
     setter_arguments->Add(value);
     super_field = new StaticCallNode(field_pos, super_setter, setter_arguments);
   }
   return super_field;
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           LocalVariable* receiver) {
-  const intptr_t supercall_pos = token_index_;
+  const intptr_t supercall_pos = TokenIndex();
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() || (super_class.num_native_fields() > 0)) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
   ctor_name = String::Concat(ctor_name, ctor_suffix);
@@ skipping 18 matching lines @@
   CheckFunctionIsCallable(supercall_pos, super_ctor);
   current_block_->statements->Add(
       new StaticCallNode(supercall_pos, super_ctor, arguments));
 }
 
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
-  const intptr_t supercall_pos = token_index_;
+  const intptr_t supercall_pos = TokenIndex();
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
@@ skipping 29 matching lines @@
              "super class constructor '%s' not found",
              ctor_name.ToCString());
   }
   CheckFunctionIsCallable(supercall_pos, super_ctor);
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls, LocalVariable* receiver) {
   TRACE_PARSER("ParseInitializer");
-  const intptr_t field_pos = token_index_;
+  const intptr_t field_pos = TokenIndex();
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
   }
   const String& field_name = *ExpectIdentifier("field name expected");
   ExpectToken(Token::kASSIGN);
 
   const bool saved_mode = SetAllowFunctionLiterals(false);
   // "this" must not be accessible in initializer expressions.
   receiver->set_invisible(true);
@@ skipping 43 matching lines @@
   Field* inst_field;
   AstNode* expr;
 };
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  GrowableArray<FieldInitExpression>* initializers) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       intptr_t field_pos = field.token_index();
       SetPosition(field_pos);
       ASSERT(IsIdentifier());
       ConsumeToken();
       ExpectToken(Token::kASSIGN);
@@ skipping 46 matching lines @@
     GenerateSuperConstructorCall(cls, receiver);
   }
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
 
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
@@ skipping 22 matching lines @@
              ctor_name.ToCString());
   }
   CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
-  const intptr_t ctor_pos = token_index_;
+  const intptr_t ctor_pos = TokenIndex();
 
   // Implicit 'this' is the only parameter/local variable.
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
@@ skipping 55 matching lines @@
     return MakeImplicitConstructor(func);
   }
 
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
-  params.AddReceiver(token_index_);
+  params.AddReceiver(TokenIndex());
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
-      token_index_,
+      TokenIndex(),
       kPhaseParameterName,
       &Type::ZoneHandle(Type::DynamicType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
@@ skipping 57 matching lines @@
     }
   }
 
   // Now parse the explicit initializer list or constructor redirection.
   ParseInitializers(cls, receiver);
 
   SequenceNode* init_statements = CloseBlock();
   if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(token_index_, *phase_param);
+    AstNode* phase_value = new LoadLocalNode(TokenIndex(), *phase_param);
     AstNode* phase_check = new BinaryOpNode(
-        token_index_, Token::kBIT_AND, phase_value,
-        new LiteralNode(token_index_,
+        TokenIndex(), Token::kBIT_AND, phase_value,
+        new LiteralNode(TokenIndex(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
-        new ComparisonNode(token_index_, Token::kNE_STRICT,
+        new ComparisonNode(TokenIndex(), Token::kNE_STRICT,
                            phase_check,
-                           new LiteralNode(token_index_,
+                           new LiteralNode(TokenIndex(),
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_init_statements =
-        new IfNode(token_index_, comparison, init_statements, NULL);
+        new IfNode(TokenIndex(), 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;
   // Look for the super initializer call in the sequence of initializer
   // statements. If it exists and is not the last initializer statement,
   // we need to create an implicit super call to the super constructor's
@@ skipping 32 matching lines @@
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
   // 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(token_index_,
+                        new LiteralNode(TokenIndex(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
 
-    ArgumentListNode* super_call_args = new ArgumentListNode(token_index_);
+    ArgumentListNode* super_call_args = new ArgumentListNode(TokenIndex());
     // First argument is the receiver.
-    super_call_args->Add(new LoadLocalNode(token_index_, *receiver));
+    super_call_args->Add(new LoadLocalNode(TokenIndex(), *receiver));
     // Second argument is the construction phase argument.
     AstNode* phase_parameter =
-    new LiteralNode(token_index_,
-                    Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
+        new LiteralNode(TokenIndex(),
+                        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(token_index_, lit->literal()));
+        super_call_args->Add(new LiteralNode(TokenIndex(), lit->literal()));
       } else {
         ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
         if (arg->IsLoadLocalNode()) {
           const LocalVariable& temp = arg->AsLoadLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(token_index_, temp));
+          super_call_args->Add(new LoadLocalNode(TokenIndex(), temp));
         } else if (arg->IsStoreLocalNode()) {
           const LocalVariable& temp = arg->AsStoreLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(token_index_, temp));
+          super_call_args->Add(new LoadLocalNode(TokenIndex(), temp));
         }
       }
     }
     ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
                                         super_call_args->names()));
     current_block_->statements->Add(
-        new StaticCallNode(token_index_, super_ctor, super_call_args));
+        new StaticCallNode(TokenIndex(), 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(token_index_, *phase_param);
+    AstNode* phase_value = new LoadLocalNode(TokenIndex(), *phase_param);
     AstNode* phase_check =
-        new BinaryOpNode(token_index_, Token::kBIT_AND,
+        new BinaryOpNode(TokenIndex(), Token::kBIT_AND,
             phase_value,
-            new LiteralNode(token_index_,
+            new LiteralNode(TokenIndex(),
                 Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
     AstNode* comparison =
-       new ComparisonNode(token_index_, Token::kNE_STRICT,
+       new ComparisonNode(TokenIndex(), Token::kNE_STRICT,
                          phase_check,
-                         new LiteralNode(token_index_,
+                         new LiteralNode(TokenIndex(),
                                          Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_block_statements =
-        new IfNode(token_index_, comparison, ctor_block, NULL);
+        new IfNode(TokenIndex(), 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 11 matching lines @@
   ParamList params;
   // Static functions do not have a receiver.
   // An instance closure may capture and access the receiver, but via the
   // context and not via the first formal parameter.
   // The first parameter of a factory is the AbstractTypeArguments vector of the
   // type of the instance to be allocated. We name this hidden parameter 'this'.
   const bool has_receiver = !func.IsClosureFunction() &&
                             (!func.is_static() || func.IsFactory());
   const bool allow_explicit_default_values = true;
   if (has_receiver) {
-    params.AddReceiver(token_index_);
+    params.AddReceiver(TokenIndex());
   }
   ASSERT(CurrentToken() == Token::kLPAREN);
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
@@ skipping 27 matching lines @@
     }
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
-    const intptr_t expr_pos = token_index_;
+    const intptr_t expr_pos = TokenIndex();
     AstNode* expr = ParseExpr(kAllowConst);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else {
     UnexpectedToken();
   }
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
@@ skipping 47 matching lines @@
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
   TRACE_PARSER("ParseQualIdent");
   ASSERT(IsIdentifier());
   ASSERT(!current_class().IsNull());
-  qual_ident->ident_pos = token_index_;
+  qual_ident->ident_pos = TokenIndex();
   qual_ident->ident = CurrentLiteral();
   qual_ident->lib_prefix = NULL;
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
         const Class& scope_class = Class::Handle(TypeParametersScopeClass());
         if (scope_class.IsNull() ||
             (scope_class.LookupTypeParameter(*(qual_ident->ident),
-                                             token_index_) ==
+                                             TokenIndex()) ==
              TypeParameter::null())) {
           ConsumeToken();  // Consume the kPERIOD token.
           qual_ident->lib_prefix = &lib_prefix;
-          qual_ident->ident_pos = token_index_;
+          qual_ident->ident_pos = TokenIndex();
           qual_ident->ident =
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   ASSERT(CurrentToken() == Token::kLPAREN);
-  intptr_t method_pos = this->token_index_;
+  intptr_t method_pos = this->TokenIndex();
   ASSERT(method->type != NULL);
   ASSERT(method->name_pos > 0);
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
     ErrorMsg(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ErrorMsg(method->name_pos, "'final' not allowed for methods");
   }
@@ skipping 22 matching lines @@
              "field or method '%s' already defined", method->name->ToCString());
   }
 
   // Parse the formal parameters.
   // The first parameter of factory methods is an implicit parameter called
   // 'this' of type AbstractTypeArguments.
   const bool has_this_param =
       !method->has_static || method->IsConstructor() || method->has_factory;
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
-  const intptr_t formal_param_pos = token_index_;
+  const intptr_t formal_param_pos = TokenIndex();
   method->params.Clear();
   if (has_this_param) {
     method->params.AddReceiver(formal_param_pos);
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
-        token_index_,
+        TokenIndex(),
         kPhaseParameterName,
         &Type::ZoneHandle(Type::DynamicType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
@@ skipping 68 matching lines @@
       ErrorMsg(method->name_pos,
                "function body not allowed in interface declaration");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
     } else {
       ConsumeToken();
       SkipExpr();
       ExpectSemicolon();
     }
-    method_end_pos = token_index_;
+    method_end_pos = TokenIndex();
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have function body",
                method->name->ToCString());
     } else if (members->is_interface()) {
       ErrorMsg(method->name_pos,
                "function body not allowed in interface declaration");
     } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
@@ skipping 119 matching lines @@
       members->AddFunction(getter);
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static, field->has_final,
                              field->name_pos);
       ParamList params;
-      params.AddReceiver(token_index_);
+      params.AddReceiver(TokenIndex());
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static, field->has_final,
                                field->name_pos);
         ParamList params;
-        params.AddReceiver(token_index_);
-        params.AddFinalParameter(token_index_, "value", field->type);
+        params.AddReceiver(TokenIndex());
+        params.AddFinalParameter(TokenIndex(), "value", field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
-    field->name_pos = this->token_index_;
+    field->name_pos = this->TokenIndex();
     field->name = ExpectIdentifier("field name expected");
   }
   ExpectSemicolon();
 }
 
 
 void Parser::CheckOperatorArity(
     const MemberDesc& member, Token::Kind operator_token) {
   intptr_t expected_num_parameters;  // Includes receiver.
   if (operator_token == Token::kASSIGN_INDEX) {
@@ skipping 101 matching lines @@
       }
       const Object& result_type_class = Object::Handle(
           UnresolvedClass::New(lib_prefix,
                                *factory_name.ident,
                                factory_name.ident_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
                                                 factory_name.ident_pos));
     } else {
-      member.name_pos = token_index_;
+      member.name_pos = TokenIndex();
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
@@ skipping 17 matching lines @@
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("left parenthesis expected");
     }
   } else if ((CurrentToken() == Token::kGET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
-    member.name_pos = this->token_index_;
+    member.name_pos = this->TokenIndex();
     member.name = ExpectIdentifier("identifier expected");
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("'(' expected");
     }
     // If the result type was not specified, it will be set to DynamicType.
   } else if ((CurrentToken() == Token::kSET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON))  {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
-    member.name_pos = this->token_index_;
+    member.name_pos = this->TokenIndex();
     member.name = ExpectIdentifier("identifier expected");
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("'(' expected");
     }
     // The grammar allows a return type, so member.type is not always NULL here.
     // If no return type is specified, the return type of the setter is Dynamic.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
   } else if ((CurrentToken() == Token::kOPERATOR) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     operator_token = CurrentToken();
     member.kind = RawFunction::kFunction;
-    member.name_pos = this->token_index_;
+    member.name_pos = this->TokenIndex();
     member.name =
         &String::ZoneHandle(String::NewSymbol(Token::Str(operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
-    member.name_pos = token_index_;
+    member.name_pos = TokenIndex();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN) {
     if (members->is_interface() && member.has_static) {
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
@@ skipping 27 matching lines @@
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseClassDefinition");
-  const intptr_t class_pos = token_index_;
+  const intptr_t class_pos = TokenIndex();
   ExpectToken(Token::kCLASS);
-  const intptr_t classname_pos = token_index_;
+  const intptr_t classname_pos = TokenIndex();
   String& class_name = *ExpectTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle();
   Object& obj = Object::Handle(library_.LookupObject(class_name));
   if (obj.IsNull()) {
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
@@ skipping 10 matching lines @@
                class_name.ToCString());
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Array::Empty());
   set_current_class(cls);
   ParseTypeParameters(cls);
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
-    const intptr_t type_pos = token_index_;
+    const intptr_t type_pos = TokenIndex();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
     if (type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
                String::Handle(type.Name()).ToCString());
     }
     super_type ^= type.raw();
     if (super_type.IsInterfaceType()) {
       ErrorMsg(type_pos,
                "class '%s' may implement, but cannot extend interface '%s'",
                class_name.ToCString(),
                String::Handle(super_type.Name()).ToCString());
     }
   } else {
     // No extends clause: Implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
-    const intptr_t interfaces_pos = token_index_;
+    const intptr_t interfaces_pos = TokenIndex();
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, cls, interfaces);
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
@@ skipping 26 matching lines @@
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
     Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
-    params.AddReceiver(token_index_);
+    params.AddReceiver(TokenIndex());
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
-        token_index_,
+        TokenIndex(),
         kPhaseParameterName,
         &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
     // The body of the constructor cannot modify the type arguments of the
     // constructed instance, which is passed in as a hidden parameter.
     // Therefore, there is no need to set the result type to be checked.
     const AbstractType& result_type = Type::ZoneHandle(Type::DynamicType());
     ctor.set_result_type(result_type);
     class_desc->AddFunction(ctor);
@@ skipping 26 matching lines @@
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
 bool Parser::IsFunctionTypeAliasName() {
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     return true;
   }
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   bool is_alias_name = false;
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (TryParseTypeParameter() && (CurrentToken() == Token::kLPAREN)) {
       is_alias_name = true;
     }
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   // Allocate an interface to hold the type parameters and their bounds.
   // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
                  Script::Handle(),
-                 token_index_));
+                 TokenIndex()));
   alias_owner.set_is_interface();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in unchecked mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
-  const intptr_t alias_name_pos = token_index_;
+  const intptr_t alias_name_pos = TokenIndex();
   const String* alias_name =
       ExpectTypeIdentifier("function alias name expected");
 
   // Parse the type parameters of the function type.
   ParseTypeParameters(alias_owner);
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(alias_owner,
                          ClassFinalizer::kTryResolve,
@@ skipping 58 matching lines @@
   ASSERT(!function_type_alias.is_finalized());
   library_.AddClass(function_type_alias);
   ExpectSemicolon();
   pending_classes.Add(function_type_alias, Heap::kOld);
 }
 
 
 void Parser::ParseInterfaceDefinition(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
-  const intptr_t interface_pos = token_index_;
+  const intptr_t interface_pos = TokenIndex();
   ExpectToken(Token::kINTERFACE);
-  const intptr_t interfacename_pos = token_index_;
+  const intptr_t interfacename_pos = TokenIndex();
   String& interface_name = *ExpectTypeIdentifier("interface name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
   }
   Class& interface = Class::Handle();
   Object& obj = Object::Handle(library_.LookupObject(interface_name));
   if (obj.IsNull()) {
     interface = Class::NewInterface(interface_name, script_, interfacename_pos);
     library_.AddClass(interface);
   } else {
@@ skipping 12 matching lines @@
                interface_name.ToCString());
     }
   }
   ASSERT(!interface.IsNull());
   ASSERT(interface.functions() == Array::Empty());
   set_current_class(interface);
   ParseTypeParameters(interface);
 
   if (CurrentToken() == Token::kEXTENDS) {
     Array& interfaces = Array::Handle();
-    const intptr_t interfaces_pos = token_index_;
+    const intptr_t interfaces_pos = TokenIndex();
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, interface, interfaces);
   }
 
   if (CurrentToken() == Token::kDEFAULT) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("class name expected");
     }
     QualIdent factory_name;
@@ skipping 120 matching lines @@
     AbstractType& bound = Type::Handle();
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
-                                          token_index_);
+                                          TokenIndex());
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.Name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ErrorMsg("duplicate type parameter '%s'",
                    type_parameter_name.ToCString());
         }
       }
       ConsumeToken();
@@ skipping 76 matching lines @@
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   String& interface_name = String::Handle();
   AbstractType& interface = AbstractType::Handle();
   String& other_name = String::Handle();
   AbstractType& other_interface = AbstractType::Handle();
   do {
     ConsumeToken();
-    intptr_t supertype_pos = token_index_;
+    intptr_t supertype_pos = TokenIndex();
     interface = ParseType(ClassFinalizer::kTryResolve);
     interface_name = interface.Name();
     for (int i = 0; i < interfaces.Length(); i++) {
       other_interface ^= interfaces.At(i);
       other_name = other_interface.Name();
       if (interface_name.Equals(other_name)) {
         ErrorMsg(supertype_pos, "Duplicate supertype '%s'",
                  interface_name.ToCString());
       }
     }
@@ skipping 51 matching lines @@
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
                                 ClassFinalizer::kIgnore));
   Field& field = Field::Handle();
   Function& getter = Function::Handle();
   while (true) {
-    const intptr_t name_pos = token_index_;
+    const intptr_t name_pos = TokenIndex();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
@@ skipping 41 matching lines @@
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kTryResolve);
     }
   }
-  const intptr_t name_pos = token_index_;
+  const intptr_t name_pos = TokenIndex();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   if (library_.LookupObject(func_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   }
   String& accessor_name = String::Handle(Field::GetterName(func_name));
   if (library_.LookupObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as getter",
              func_name.ToCString());
   }
   accessor_name = Field::SetterName(func_name);
   if (library_.LookupObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as setter",
              func_name.ToCString());
   }
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  const intptr_t function_pos = token_index_;
+  const intptr_t function_pos = TokenIndex();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   intptr_t function_end_pos = function_pos;
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
-    function_end_pos = token_index_;
+    function_end_pos = TokenIndex();
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
-    function_end_pos = token_index_;
+    function_end_pos = TokenIndex();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(func_name, RawFunction::kFunction,
                     is_static, false, function_pos));
   func.set_result_type(result_type);
   func.set_end_token_index(function_end_pos);
@@ skipping 19 matching lines @@
     } else {
       result_type = ParseType(ClassFinalizer::kTryResolve);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
-  const intptr_t name_pos = token_index_;
+  const intptr_t name_pos = TokenIndex();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  const intptr_t accessor_pos = token_index_;
+  const intptr_t accessor_pos = TokenIndex();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
   String& accessor_name = String::ZoneHandle();
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
@@ skipping 76 matching lines @@
     prev_error ^= Api::UnwrapHandle(result);
     AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
   TRACE_PARSER("ParseLibraryImport");
   while (CurrentToken() == Token::kIMPORT) {
-    const intptr_t import_pos = token_index_;
+    const intptr_t import_pos = TokenIndex();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *ParseImportStringLiteral();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       if (!IsLiteral("prefix")) {
@@ skipping 43 matching lines @@
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
   TRACE_PARSER("ParseLibraryInclude");
   while (CurrentToken() == Token::kSOURCE) {
-    const intptr_t source_pos = token_index_;
+    const intptr_t source_pos = TokenIndex();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
     const String& url = *ParseImportStringLiteral();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
@@ skipping 44 matching lines @@
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(isolate, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::Handle(
       Class::New(String::ZoneHandle(String::NewSymbol("::")),
                  script_,
-                 token_index_));
+                 TokenIndex()));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(pending_classes);
@@ skipping 32 matching lines @@
 
     library_.AddAnonymousClass(toplevel_class);
     pending_classes.Add(toplevel_class, Heap::kOld);
   }
 }
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
   Block* block = new Block(current_block_,
                            outer_scope,
-                           new SequenceNode(token_index_, outer_scope));
+                           new SequenceNode(TokenIndex(), outer_scope));
   current_block_ = block;
 }
 
 
 void Parser::OpenBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
   ChainNewBlock(new LocalScope(outer_scope,
                                outer_scope->function_level(),
                                outer_scope->loop_level()));
@@ skipping 33 matching lines @@
   ChainNewBlock(outer_scope);
 }
 
 
 SequenceNode* Parser::CloseBlock() {
   SequenceNode* statements = current_block_->statements;
   if (current_block_->scope != NULL) {
     // Record the begin and end token index of the scope.
     ASSERT(statements != NULL);
     current_block_->scope->set_begin_token_index(statements->token_index());
-    current_block_->scope->set_end_token_index(token_index_);
+    current_block_->scope->set_end_token_index(TokenIndex());
   }
   current_block_ = current_block_->parent;
   return statements;
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array& default_values) {
   if (params->num_optional_parameters > 0) {
@@ skipping 60 matching lines @@
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   func.set_is_native(true);
   TRACE_PARSER("ParseNativeFunctionBlock");
   const Class& cls = Class::Handle(func.owner());
   const int num_parameters = params->parameters->length();
   const bool is_instance_closure = func.IsImplicitInstanceClosureFunction();
   int num_params_for_resolution = num_parameters;
 
   // Parse the function name out.
-  const intptr_t native_pos = token_index_;
+  const intptr_t native_pos = TokenIndex();
   const String& native_name = ParseNativeDeclaration();
 
   if (is_instance_closure) {
     num_params_for_resolution += 1;  // account for 'this' when resolving.
   }
   // Now resolve the native function to the corresponding native entrypoint.
   NativeFunction native_function = NativeEntry::ResolveNative(
       cls, native_name, num_params_for_resolution);
   if (native_function == NULL) {
     ErrorMsg(native_pos, "native function '%s' cannot be found",
         native_name.ToCString());
   }
 
   const bool has_opt_params = (params->num_optional_parameters > 0);
 
   // Now add the NativeBodyNode and return statement.
   current_block_->statements->Add(
-      new ReturnNode(token_index_, new NativeBodyNode(token_index_,
+      new ReturnNode(TokenIndex(), new NativeBodyNode(TokenIndex(),
                                                       native_name,
                                                       native_function,
                                                       num_parameters,
                                                       has_opt_params,
                                                       is_instance_closure)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope,
                                       bool test_only) {
@@ skipping 23 matching lines @@
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   // We should not be loading the receiver from a static scope.
   ASSERT(!current_function().is_static() ||
          current_function().IsInFactoryScope());
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
   }
-  return new LoadLocalNode(token_index_, *receiver);
+  return new LoadLocalNode(TokenIndex(), *receiver);
 }
 
 
 AstNode* Parser::CallGetter(intptr_t token_index,
                             AstNode* object,
                             const String& name) {
-  return new InstanceGetterNode(token_index_, object, name);
+  return new InstanceGetterNode(TokenIndex(), object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(
     const AbstractType& type, bool is_final) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
-  const intptr_t ident_pos = token_index_;
+  const intptr_t ident_pos = TokenIndex();
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
-    const intptr_t assign_pos = token_index_;
+    const intptr_t assign_pos = TokenIndex();
     ConsumeToken();
     AstNode* expr = ParseExpr(kAllowConst);
     initialization = new StoreLocalNode(assign_pos, *variable, expr);
   } else if (is_final) {
     ErrorMsg(ident_pos, "missing initialization of 'final' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
     initialization = new StoreLocalNode(ident_pos, *variable, null_expr);
   }
@@ skipping 87 matching lines @@
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if ((CurrentToken() == Token::kIDENT) &&
              (LookaheadToken(1) != Token::kLPAREN)) {
     result_type = ParseType(ClassFinalizer::kFinalize);
   }
-  const intptr_t ident_pos = token_index_;
+  const intptr_t ident_pos = TokenIndex();
   if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
     const String& anonymous_function_name =
         String::ZoneHandle(String::NewSymbol("function"));
     function_name = &anonymous_function_name;
   }
   ASSERT(ident_pos >= 0);
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  intptr_t function_pos = token_index_;
+  intptr_t function_pos = TokenIndex();
 
   // 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
   // and non-closurized versions of the same parent function.
   Function& function = Function::ZoneHandle();
   bool is_new_closure = false;
   // TODO(hausner): There could be two different closures at the given
   // function_pos, one enclosed in a closurized function and one enclosed in the
@@ skipping 39 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_index() == token_index_));
-  function.set_end_token_index(token_index_);
+  ASSERT(is_new_closure || (function.end_token_index() == TokenIndex()));
+  function.set_end_token_index(TokenIndex());
 
   // 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(
       library_.LookupLocalClass(signature));
 
   if (signature_class.IsNull()) {
     // If we don't have a signature class yet, this must be a closure we
@@ skipping 158 matching lines @@
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
   if (CurrentToken() != Token::kIDENT) {
     // Not a legal type identifier.
     return false;
   }
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   bool is_var_decl = false;
   if (TryParseOptionalType()) {
     if (IsIdentifier()) {
       ConsumeToken();
       if ((CurrentToken() == Token::kSEMICOLON) ||
           (CurrentToken() == Token::kCOMMA) ||
           (CurrentToken() == Token::kASSIGN)) {
         is_var_decl = true;
       }
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
 // a function declaration. Token position remains unchanged.
 bool Parser::IsFunctionDeclaration() {
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     // Possibly a function without explicit return type.
     ConsumeToken();  // Consume function identifier.
   } else if (TryParseReturnType()) {
     if (!IsIdentifier()) {
       SetPosition(saved_pos);
       return false;
     }
     ConsumeToken();  // Consume function identifier.
   } else {
@@ skipping 12 matching lines @@
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     return true;
   }
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   if (TryParseReturnType()) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
       if (Token::IsIdentifier(LookaheadToken(1))) {  // Accessor name.
         SetPosition(saved_pos);
         return true;
       }
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsFunctionLiteral() {
   if (!allow_function_literals_) {
     return false;
   }
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   bool is_function_literal = false;
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     ConsumeToken();  // Consume function identifier.
   } else if (TryParseReturnType()) {
     if (!IsIdentifier()) {
       SetPosition(saved_pos);
       return false;
     }
     ConsumeToken();  // Comsume function identifier.
   }
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW)) {
       is_function_literal = true;
     }
   }
   SetPosition(saved_pos);
   return is_function_literal;
 }
 
 
 // Current token position is the token after the opening ( of the for
 // statement. Returns true if we recognize a for ( .. in expr)
 // statement.
 bool Parser::IsForInStatement() {
-  const intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = TokenIndex();
   bool result = false;
   if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL) {
     ConsumeToken();
   }
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kIN) {
       result = true;
     } else if (TryParseOptionalType()) {
       if (IsIdentifier()) {
         ConsumeToken();
@@ skipping 25 matching lines @@
   }
   return false;
 }
 
 
 void Parser::ParseStatementSequence() {
   TRACE_PARSER("ParseStatementSequence");
   const bool dead_code_allowed = true;
   bool abrupt_completing_seen = false;
   while (CurrentToken() != Token::kRBRACE) {
-    const intptr_t statement_pos = token_index_;
+    const intptr_t statement_pos = TokenIndex();
     AstNode* statement = ParseStatement();
     // Do not add statements with no effect (e.g., LoadLocalNode).
     if ((statement != NULL) && statement->IsLoadLocalNode()) {
       // Skip load local.
       statement = statement->AsLoadLocalNode()->pseudo();
     }
     if (statement != NULL) {
       if (!dead_code_allowed && abrupt_completing_seen) {
         ErrorMsg(statement_pos, "dead code after abrupt completing statement");
       }
@@ skipping 29 matching lines @@
     }
   }
   SequenceNode* sequence = CloseBlock();
   return sequence;
 }
 
 
 AstNode* Parser::ParseIfStatement(String* label_name) {
   TRACE_PARSER("ParseIfStatement");
   ASSERT(CurrentToken() == Token::kIF);
-  const intptr_t if_pos = token_index_;
+  const intptr_t if_pos = TokenIndex();
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
@@ skipping 12 matching lines @@
     if_node = sequence;
   }
   return if_node;
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseStatement");
   bool default_seen = false;
-  const intptr_t case_pos = token_index_;
+  const intptr_t case_pos = TokenIndex();
   // The case expressions node sequence does not own the enclosing scope.
   SequenceNode* case_expressions = new SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
-      const intptr_t expr_pos = token_index_;
+      const intptr_t expr_pos = TokenIndex();
       AstNode* expr = ParseExpr(kAllowConst);
       AstNode* switch_expr_load = new LoadLocalNode(case_pos,
                                                     *switch_expr_value);
       AstNode* case_comparison = new ComparisonNode(expr_pos,
                                                     Token::kEQ,
                                                     expr,
                                                     switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
@@ skipping 19 matching lines @@
       next_token = CurrentToken();
     }
     if (next_token == Token::kRBRACE) {
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
       // the next case clause, throw an implicit FallThroughError.
       if (!abrupt_completing_seen) {
-        ArgumentListNode* arguments = new ArgumentListNode(token_index_);
+        ArgumentListNode* arguments = new ArgumentListNode(TokenIndex());
         arguments->Add(new LiteralNode(
-            token_index_, Integer::ZoneHandle(Integer::New(token_index_))));
+            TokenIndex(), Integer::ZoneHandle(Integer::New(TokenIndex()))));
         current_block_->statements->Add(
             MakeStaticCall(kFallThroughErrorName, kThrowNewName, arguments));
       }
       break;
     }
     // The next statement still belongs to this case.
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
   SequenceNode* statements = CloseBlock();
   return new CaseNode(case_pos, case_label,
       case_expressions, default_seen, switch_expr_value, statements);
 }
 
 
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
-  const intptr_t switch_pos = token_index_;
+  const intptr_t switch_pos = TokenIndex();
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   const bool parens_are_mandatory = false;
   bool paren_found = false;
   if (CurrentToken() == Token::kLPAREN) {
     paren_found = true;
     ConsumeToken();
   } else if (parens_are_mandatory) {
     ErrorMsg("'(' expected");
   }
-  const intptr_t expr_pos = token_index_;
+  const intptr_t expr_pos = TokenIndex();
   AstNode* switch_expr = ParseExpr(kAllowConst);
   if (paren_found) {
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
                         String::ZoneHandle(String::NewSymbol(":switch_expr")),
                         Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr =
       new StoreLocalNode(expr_pos, *temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
     if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
-      const intptr_t label_pos = token_index_;
+      const intptr_t label_pos = TokenIndex();
       ConsumeToken();  // Consume label identifier.
       ConsumeToken();  // Consume colon.
       case_label = current_block_->scope->LocalLookupLabel(*label_name);
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
         case_label =
             new SourceLabel(label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
         // We have seen a 'continue' with this label name. Resolve
@@ skipping 31 matching lines @@
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
   return new SwitchNode(switch_pos, label, switch_body);
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
-  const intptr_t while_pos = token_index_;
+  const intptr_t while_pos = TokenIndex();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
   return new WhileNode(while_pos, label, cond_expr, while_body);
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
-  const intptr_t do_pos = token_index_;
+  const intptr_t do_pos = TokenIndex();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
-    loop_var_pos = token_index_;
+    loop_var_pos = TokenIndex();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
                                 ClassFinalizer::kIgnore));
-    loop_var_pos = token_index_;
+    loop_var_pos = TokenIndex();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
-  const intptr_t collection_pos = token_index_;
+  const intptr_t collection_pos = TokenIndex();
   AstNode* collection_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
       String::ZoneHandle(String::NewSymbol(":for-in-iter"));
   // 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
@@ skipping 71 matching lines @@
   AstNode* while_statement =
       new WhileNode(forin_pos, label, iterator_has_next, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
-  const intptr_t for_pos = token_index_;
+  const intptr_t for_pos = TokenIndex();
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
   if (IsForInStatement()) {
     return ParseForInStatement(for_pos, label);
   }
   OpenBlock();
   // The label is added to the implicit scope that also contains
   // the loop variable declarations.
   current_block_->scope->AddLabel(label);
   AstNode* initializer = NULL;
-  const intptr_t init_pos = token_index_;
+  const intptr_t init_pos = TokenIndex();
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
       initializer = ParseExpr(kAllowConst);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
     condition = ParseExpr(kAllowConst);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
-  const intptr_t incr_pos = token_index_;
+  const intptr_t incr_pos = TokenIndex();
   LocalScope* incr_scope = current_block_->scope;
   if (CurrentToken() != Token::kRPAREN) {
     increment = ParseExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* body = ParseNestedStatement(parsing_loop_body, NULL);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
@@ skipping 67 matching lines @@
     cond_expr->set_false_expr(InsertClosureCallNodes(cond_expr->false_expr()));
   }
   return condition;
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
-  const intptr_t condition_pos = token_index_;
+  const intptr_t condition_pos = TokenIndex();
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst);
-  const intptr_t condition_end = token_index_;
+  const intptr_t condition_end = TokenIndex();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
                     NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
 
@@ skipping 10 matching lines @@
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   // The type of the catch parameter must always be resolved, even in unchecked
   // mode.
   catch_param->type = &AbstractType::ZoneHandle(
       ParseFinalVarOrType(ClassFinalizer::kFinalizeWellFormed));
-  catch_param->token_index = token_index_;
+  catch_param->token_index = TokenIndex();
   catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
   LocalVariable* var = new LocalVariable(exception_param.token_index,
                                          *exception_param.var,
                                          *exception_param.type);
   if (exception_param.is_final) {
     var->set_is_final();
   }
   bool added_to_scope = scope->AddVariable(var);
   ASSERT(added_to_scope);
   if (stack_trace_param.var != NULL) {
-    var = new LocalVariable(token_index_,
+    var = new LocalVariable(TokenIndex(),
                             *stack_trace_param.var,
                             *stack_trace_param.type);
     if (stack_trace_param.is_final) {
       var->set_is_final();
     }
     added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
       ErrorMsg(stack_trace_param.token_index,
                "name '%s' already exists in scope",
                stack_trace_param.var->ToCString());
@@ skipping 78 matching lines @@
   //                     the stack trace was copied into when an exception was
   //                     thrown.
   // :exception_var and :stacktrace_var get set with the exception object
   // and the stacktrace object when an exception is thrown.
   // These three implicit variables can never be captured variables.
   const String& context_var_name =
       String::ZoneHandle(String::NewSymbol(":saved_context_var"));
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(context_var_name);
   if (context_var == NULL) {
-    context_var = new LocalVariable(token_index_,
+    context_var = new LocalVariable(TokenIndex(),
                                     context_var_name,
                                     Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   const String& catch_excp_var_name =
       String::ZoneHandle(String::NewSymbol(":exception_var"));
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(catch_excp_var_name);
   if (catch_excp_var == NULL) {
-    catch_excp_var = new LocalVariable(token_index_,
+    catch_excp_var = new LocalVariable(TokenIndex(),
                                        catch_excp_var_name,
                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   const String& catch_trace_var_name =
       String::ZoneHandle(String::NewSymbol(":stacktrace_var"));
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(catch_trace_var_name);
   if (catch_trace_var == NULL) {
-    catch_trace_var = new LocalVariable(token_index_,
+    catch_trace_var = new LocalVariable(TokenIndex(),
                                         catch_trace_var_name,
                                         Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
-  const intptr_t try_pos = token_index_;
+  const intptr_t try_pos = TokenIndex();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   Block* current_try_block = current_block_;
   PushTryBlock(current_try_block);
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   // Now create a label for the end of catch block processing so that we can
   // jump over the catch block code after executing the try block.
   SourceLabel* end_catch_label =
-      SourceLabel::New(token_index_, NULL, SourceLabel::kCatch);
+      SourceLabel::New(TokenIndex(), NULL, SourceLabel::kCatch);
 
   // Now parse the 'catch' blocks if any and merge all of them into
   // an if-then sequence of the different types specified using the 'is'
   // operator.
   bool catch_seen = false;
   bool generic_catch_seen = false;
   SequenceNode* catch_handler_list = NULL;
-  const intptr_t handler_pos = token_index_;
+  const intptr_t handler_pos = TokenIndex();
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   while (CurrentToken() == Token::kCATCH) {
     catch_seen = true;
-    const intptr_t catch_pos = token_index_;
+    const intptr_t catch_pos = TokenIndex();
     ConsumeToken();  // Consume the 'catch'.
     ExpectToken(Token::kLPAREN);
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     ParseCatchParameter(&exception_param);
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       ParseCatchParameter(&stack_trace_param);
     }
     ExpectToken(Token::kRPAREN);
@@ skipping 74 matching lines @@
     current_block_->statements->Add(catch_clause);
   }
   catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
     current_function_.set_is_optimizable(false);
     ConsumeToken();  // Consume the 'finally'.
-    const intptr_t finally_pos = token_index_;
+    const intptr_t finally_pos = TokenIndex();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
                                                         *context_var);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
-      token_index_ = finally_pos;
+      tokens_iterator_.SetCurrentIndex(finally_pos);
     }
     if (!generic_catch_seen) {
       // No generic catch handler exists so execute this finally block
       // before rethrowing the exception.
       finally_block = ParseFinallyBlock();
       catch_handler_list->Add(finally_block);
-      token_index_ = finally_pos;
+      tokens_iterator_.SetCurrentIndex(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   } else {
     if (!catch_seen) {
       ErrorMsg("'catch' or 'finally' expected");
     }
   }
 
   if (!generic_catch_seen) {
     // No generic catch handler exists so rethrow the exception so that
@@ skipping 23 matching lines @@
     try_catch_node = sequence;
   }
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
   TRACE_PARSER("ParseJump");
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
-  const intptr_t jump_pos = token_index_;
+  const intptr_t jump_pos = TokenIndex();
   SourceLabel* target = NULL;
   ConsumeToken();
   if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
     if (label_name != NULL && target_name.Equals(*label_name)) {
       if (jump_kind == Token::kCONTINUE) {
         ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
                  target_name.ToCString());
       }
       // L: break L; is a no-op.
       return NULL;
     }
     target = current_block_->scope->LookupLabel(target_name);
     if (target == NULL && jump_kind == Token::kCONTINUE) {
       // Either a reference to a non-existent label, or a forward reference
       // to a case label that we haven't seen yet. If we are inside a switch
       // statement, create a "forward reference" label in the scope of
       // the switch statement.
       LocalScope* switch_scope = current_block_->scope->LookupSwitchScope();
       if (switch_scope != NULL) {
         // We found a switch scope. Enter a forward reference to the label.
         target = new SourceLabel(
-            token_index_, target_name, SourceLabel::kForward);
+            TokenIndex(), target_name, SourceLabel::kForward);
         switch_scope->AddLabel(target);
       }
     }
     if (target == NULL) {
       ErrorMsg(jump_pos, "label '%s' not found", target_name.ToCString());
     }
   } else {
     target = current_block_->scope->LookupInnermostLabel(jump_kind);
     if (target == NULL) {
       ErrorMsg(jump_pos, "'%s' is illegal here", Token::Str(jump_kind));
@@ skipping 13 matching lines @@
   }
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
     ErrorMsg(jump_pos, "'%s' target must be in same function context",
              Token::Str(jump_kind));
   }
   return new JumpNode(jump_pos, jump_kind, target);
 }
 
 
 bool Parser::IsDefinedInLexicalScope(const String& ident) {
-  if (ResolveIdentInLocalScope(token_index_, ident, NULL)) {
+  if (ResolveIdentInLocalScope(TokenIndex(), ident, NULL)) {
     return true;
   }
   Object& obj = Object::Handle();
   obj = library_.LookupObject(ident);
   return !obj.IsNull();
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   intptr_t label_pos = 0;
   String* label_name = NULL;
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kCOLON) {
       // Statement starts with a label.
       label_name = CurrentLiteral();
-      label_pos = token_index_;
+      label_pos = TokenIndex();
       ASSERT(label_pos > 0);
       ConsumeToken();  // Consume identifier.
       ConsumeToken();  // Consume colon.
     }
   }
-  const intptr_t statement_pos = token_index_;
+  const intptr_t statement_pos = TokenIndex();
 
   if (CurrentToken() == Token::kWHILE) {
     statement = ParseWhileStatement(label_name);
   } else if (CurrentToken() == Token::kFOR) {
     statement = ParseForStatement(label_name);
   } else if (CurrentToken() == Token::kDO) {
     statement = ParseDoWhileStatement(label_name);
   } else if (CurrentToken() == Token::kSWITCH) {
     statement = ParseSwitchStatement(label_name);
   } else if (CurrentToken() == Token::kTRY) {
     statement = ParseTryStatement(label_name);
   } else if (CurrentToken() == Token::kRETURN) {
-    const intptr_t return_pos = token_index_;
+    const intptr_t return_pos = TokenIndex();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ErrorMsg(return_pos, "return of a value not allowed in constructors");
       }
       AstNode* expr = ParseExpr(kAllowConst);
       statement = new ReturnNode(statement_pos, expr);
     } else {
       statement = new ReturnNode(statement_pos);
@@ skipping 174 matching lines @@
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
-      FormatError(script_, token_index_, "Error", format, args));
+      FormatError(script_, TokenIndex(), "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
@@ skipping 25 matching lines @@
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Warning(const char* format, ...) {
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
-      FormatError(script_, token_index_, "Warning", format, args));
+      FormatError(script_, TokenIndex(), "Warning", format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
-  ErrorMsg(token_index_, msg);
+  ErrorMsg(TokenIndex(), msg);
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
     ErrorMsg("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
 }
 
@@ skipping 93 matching lines @@
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       if (op_kind == Token::kTIGHTADD) {
         op_kind = Token::kADD;
       }
-      const intptr_t op_pos = token_index_;
+      const intptr_t op_pos = TokenIndex();
       ConsumeToken();
       AstNode* right_operand = NULL;
       if (op_kind != Token::kIS) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' we expect the right operand to be a type.
         if (CurrentToken() == Token::kNOT) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
-        const intptr_t type_pos = token_index_;
+        const intptr_t type_pos = TokenIndex();
         const AbstractType& type =
             AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
         if (type.IsMalformed()) {
           // Note that a type error is thrown even if the tested value is null.
@@ skipping 30 matching lines @@
       || expr->IsInstanceGetterNode()
       || expr->IsLoadIndexedNode();
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
-    SequenceNode* list = new SequenceNode(token_index_, NULL);
+    SequenceNode* list = new SequenceNode(TokenIndex(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
@@ skipping 180 matching lines @@
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() || result->IsInstanceSetterNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const) {
   TRACE_PARSER("ParseExpr");
-  const intptr_t expr_pos = token_index_;
+  const intptr_t expr_pos = TokenIndex();
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     }
     return expr;
   }
   // Assignment expressions.
   Token::Kind assignment_op = CurrentToken();
-  const intptr_t assignment_pos = token_index_;
+  const intptr_t assignment_pos = TokenIndex();
   ConsumeToken();
-  const intptr_t right_expr_pos = token_index_;
+  const intptr_t right_expr_pos = TokenIndex();
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
     ErrorMsg(right_expr_pos, "expression must be a compile time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const);
   AstNode* left_expr = expr;
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     left_expr = PrepareCompoundAssignmentNodes(&expr);
   }
   right_expr =
@@ skipping 11 matching lines @@
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
   AstNode* expr = ParseExpr(kRequireConst);
   ASSERT(expr->IsLiteralNode());
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
-  const intptr_t expr_pos = token_index_;
+  const intptr_t expr_pos = TokenIndex();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst);
     expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
-  const intptr_t op_pos = token_index_;
+  const intptr_t op_pos = TokenIndex();
   if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (unary_op == Token::kTIGHTADD) {
       // kTIGHADD is added only in front of a number literal.
       if (!expr->IsLiteralNode()) {
         ErrorMsg(op_pos, "unexpected operator '+'");
       }
       // Expression is the literal itself.
@@ skipping 26 matching lines @@
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
                               bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
-    arguments = new ArgumentListNode(token_index_);
+    arguments = new ArgumentListNode(TokenIndex());
   } else {
     arguments = implicit_arguments;
   }
   const GrowableObjectArray& names =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
     String& arg_name = String::Handle();
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
@@ skipping 28 matching lines @@
     arguments->set_names(Array::Handle(Array::MakeArray(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticCall");
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   const int num_arguments = arguments->length();
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               num_arguments,
                               arguments->names(),
                               Resolver::kIsQualified));
   if (func.IsNull()) {
@@ skipping 29 matching lines @@
     // Could not resolve static method: throw an exception if the arguments
     // do not match or compile time error otherwise.
     const Function& test_func = Function::Handle(
         Resolver::ResolveStaticByName(cls, func_name, Resolver::kIsQualified));
     if (test_func.IsNull()) {
       ErrorMsg(ident_pos, "unresolved static method '%s'",
           func_name.ToCString());
     } else {
       ArgumentListNode* arguments = new ArgumentListNode(ident_pos);
       arguments->Add(new LiteralNode(
-          token_index_, Integer::ZoneHandle(Integer::New(ident_pos))));
+          TokenIndex(), Integer::ZoneHandle(Integer::New(ident_pos))));
       return MakeStaticCall(kStaticResolutionExceptionName,
                             kThrowNewName,
                             arguments);
     }
   }
   CheckFunctionIsCallable(call_pos, func);
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg(call_pos, "left parenthesis expected");
   }
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   ASSERT(CurrentToken() == Token::kLPAREN);
   EnsureExpressionTemp();
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new ClosureCallNode(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceFieldAccess(AstNode* receiver,
                                           const String& field_name) {
   TRACE_PARSER("ParseInstanceFieldAccess");
   AstNode* access = NULL;
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     Token::Kind assignment_op = CurrentToken();
     ConsumeToken();
     AstNode* value = ParseExpr(kAllowConst);
     AstNode* load_access =
         new InstanceGetterNode(call_pos, receiver, field_name);
     AstNode* left_load_access = load_access;
     if (assignment_op != Token::kASSIGN) {
       // Compound assignment: store inputs with side effects into temp. locals.
       left_load_access = PrepareCompoundAssignmentNodes(&load_access);
@@ skipping 26 matching lines @@
   // Access the field directly.
   return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticFieldAccess");
   AstNode* access = NULL;
-  const intptr_t call_pos = token_index_;
+  const intptr_t call_pos = TokenIndex();
   const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     Token::Kind assignment_op = CurrentToken();
     if (field.IsNull()) {
       // No field, check if we have an explicit setter function.
       const String& setter_name =
           String::ZoneHandle(Field::SetterName(field_name));
       const int kNumArguments = 1;  // value.
       const Array& kNoArgumentNames = Array::Handle();
@@ skipping 25 matching lines @@
     } else {
       // Field exists.
       if (field.is_final()) {
         // Field has been marked as final, report an error as the field
         // is not settable.
         ErrorMsg(ident_pos,
                  "field '%s' is const static, cannot assign to it",
                  field_name.ToCString());
         return access;
       }
-      load_access = GenerateStaticFieldLookup(field, token_index_);
+      load_access = GenerateStaticFieldLookup(field, TokenIndex());
     }
     value = ExpandAssignableOp(call_pos, assignment_op, load_access, value);
     access = CreateAssignmentNode(load_access, value);
   } else {  // Not Token::IsAssignmentOperator(CurrentToken()).
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(field_name));
       const int kNumArguments = 0;  // no arguments.
       const Array& kNoArgumentNames = Array::Handle();
@@ skipping 13 matching lines @@
           return access;
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         access = new StaticGetterNode(call_pos,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
-      return GenerateStaticFieldLookup(field, token_index_);
+      return GenerateStaticFieldLookup(field, TokenIndex());
     }
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
@@ skipping 36 matching lines @@
     }
     AstNode* receiver = LoadReceiver(primary->token_index());
     closure = CallGetter(primary->token_index(), receiver, funcname);
   }
   return closure;
 }
 
 
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
-  const intptr_t postfix_expr_pos = token_index_;
+  const intptr_t postfix_expr_pos = TokenIndex();
   AstNode* postfix_expr = ParsePrimary();
   while (true) {
     AstNode* selector = NULL;
     AstNode* left = postfix_expr;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         if (left->AsPrimaryNode()->primary().IsFunction()) {
           left = LoadClosure(left->AsPrimaryNode());
         } else {
           left = LoadFieldIfUnresolved(left);
         }
       }
-      const intptr_t ident_pos = token_index_;
+      const intptr_t ident_pos = TokenIndex();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode()
             && left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
           Class& cls = Class::CheckedHandle(
               left->AsPrimaryNode()->primary().raw());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
@@ skipping 12 matching lines @@
         }
         if (cls.IsNull()) {
           // Instance field access.
           selector = ParseInstanceFieldAccess(left, *ident);
         } else {
           // Static field access.
           selector = ParseStaticFieldAccess(cls, *ident, ident_pos);
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
-      const intptr_t bracket_pos = token_index_;
+      const intptr_t bracket_pos = TokenIndex();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
@@ skipping 247 matching lines @@
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                String::Handle(field.name()).ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
-      return new StaticGetterNode(token_index_,
+      return new StaticGetterNode(TokenIndex(),
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   } else if (value.raw() == Object::sentinel()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Instance::Handle(Object::transition_sentinel()));
       const String& field_name = String::Handle(field.name());
@@ skipping 13 matching lines @@
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeStatic(func, arguments, kNoArgumentNames));
       if (const_value.IsError()) {
         Error& error = Error::Handle();
         error ^= const_value.raw();
         if (const_value.IsUnhandledException()) {
           field.set_value(Instance::Handle());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
-          AppendErrorMsg(error, token_index_,
+          AppendErrorMsg(error, TokenIndex(),
                          "error initializing final field '%s'",
                          String::Handle(field.name()).ToCString());
         } else {
           Isolate::Current()->long_jump_base()->Jump(1, error);
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle();
       instance ^= const_value.raw();
       if (!instance.IsNull()) {
         instance ^= instance.Canonicalize();
       }
       field.set_value(instance);
     } else {
-      return new StaticGetterNode(token_index_,
+      return new StaticGetterNode(TokenIndex(),
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   }
   return NULL;
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
@@ skipping 417 matching lines @@
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseListLiteral(intptr_t type_pos,
                                   bool is_const,
                                   const AbstractTypeArguments& type_arguments) {
   TRACE_PARSER("ParseListLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
-  const intptr_t literal_pos = token_index_;
+  const intptr_t literal_pos = TokenIndex();
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
   AbstractType& element_type = Type::ZoneHandle(Type::DynamicType());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using Dynamic as the type argument for the element type.
   if (!type_arguments.IsNull()) {
     ASSERT(type_arguments.Length() > 0);
     // List literals take a single type argument.
     element_type = type_arguments.TypeAt(0);
     if (type_arguments.Length() != 1) {
       ErrorMsg(type_pos,
                "a list literal takes one type argument specifying "
                "the element type");
     }
     if (is_const && !element_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant list literal cannot include "
                "a type variable");
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
-  ArrayNode* list = new ArrayNode(token_index_, type_arguments);
+  ArrayNode* list = new ArrayNode(TokenIndex(), type_arguments);
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(
         String::NewSymbol("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
-      const intptr_t element_pos = token_index_;
+      const intptr_t element_pos = TokenIndex();
       AstNode* element = ParseExpr(is_const);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new AssignableNode(element_pos,
                                      element,
                                      element_type,
                                      dst_name);
       }
       list->AddElement(element);
@@ skipping 111 matching lines @@
   pairs->AddElement(value);
 }
 
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
                                  const AbstractTypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
-  const intptr_t literal_pos = token_index_;
+  const intptr_t literal_pos = TokenIndex();
   ConsumeToken();
 
   AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
   AbstractTypeArguments& map_type_arguments =
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using Dynamic as the type argument for the value type.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take a single type argument.
@@ skipping 27 matching lines @@
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   // The kv_pair array is temporary and of element type Dynamic. It is passed
   // to the factory to initialize a properly typed map.
   ArrayNode* kv_pairs =
-      new ArrayNode(token_index_, TypeArguments::ZoneHandle());
+      new ArrayNode(TokenIndex(), TypeArguments::ZoneHandle());
   const String& dst_name = String::ZoneHandle(
       String::NewSymbol("list literal element"));
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
       ErrorMsg("map entry key must be string literal");
     } else if (is_const && !key->IsLiteralNode()) {
       ErrorMsg("map entry key must be compile time constant string");
     }
     ExpectToken(Token::kCOLON);
     const bool saved_mode = SetAllowFunctionLiterals(true);
-    const intptr_t value_pos = token_index_;
+    const intptr_t value_pos = TokenIndex();
     AstNode* value = ParseExpr(is_const);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new AssignableNode(value_pos,
                                  value,
                                  value_type,
                                  dst_name);
     }
@@ skipping 42 matching lines @@
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
         String::Handle(String::NewSymbol(kImmutableMapName));
     const Class& immutable_map_class =
         Class::Handle(LookupImplClass(immutable_map_class_name));
     ASSERT(!immutable_map_class.IsNull());
-    ArgumentListNode* constr_args = new ArgumentListNode(token_index_);
+    ArgumentListNode* constr_args = new ArgumentListNode(TokenIndex());
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
         String::Handle(String::NewSymbol(kImmutableMapConstructorName));
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
@@ skipping 33 matching lines @@
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
-  const intptr_t type_pos = token_index_;
+  const intptr_t type_pos = TokenIndex();
   Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle(
       ParseTypeArguments(&malformed_error,
                          ClassFinalizer::kFinalizeWellFormed));
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we should never see a malformed type error here.
   // Note that a bound error is the only possible malformed type error returned
   // when requesting kFinalizeWellFormed type finalization.
   ASSERT(malformed_error.IsNull());
   AstNode* primary = NULL;
@@ skipping 20 matching lines @@
       String::Handle(String::Concat(type_class_name, period));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator() {
   TRACE_PARSER("ParseNewOperator");
-  const intptr_t new_pos = token_index_;
+  const intptr_t new_pos = TokenIndex();
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
-  intptr_t type_pos = token_index_;
+  intptr_t type_pos = TokenIndex();
   const AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kFinalizeWellFormed));
   // Malformed bounds never result in a compile time error, therefore, the
   // parsed type may be malformed although we requested kFinalizeWellFormed.
   // In that case, we throw a dynamic type error instead of calling the
   // constructor.
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
              String::Handle(type.Name()).ToCString());
@@ skipping 19 matching lines @@
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  intptr_t call_pos = token_index_;
+  intptr_t call_pos = TokenIndex();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   if (type_class.is_interface()) {
     // We need to make sure that an appropriate constructor is
     // declared in the interface.
@@ skipping 201 matching lines @@
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token.
 AstNode* Parser::ParseStringLiteral() {
   TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
-  const intptr_t literal_start = token_index_;
+  const intptr_t literal_start = TokenIndex();
   ASSERT(CurrentToken() == Token::kSTRING);
   Token::Kind l1_token = LookaheadToken(1);
   if ((l1_token != Token::kSTRING) &&
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   bool is_compiletime_const = true;
-  ArrayNode* values = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
+  ArrayNode* values = new ArrayNode(TokenIndex(), TypeArguments::ZoneHandle());
   while (CurrentToken() == Token::kSTRING) {
-    values->AddElement(new LiteralNode(token_index_, *CurrentLiteral()));
+    values->AddElement(new LiteralNode(TokenIndex(), *CurrentLiteral()));
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
-      const intptr_t expr_pos = token_index_;
+      const intptr_t expr_pos = TokenIndex();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
-        expr = ResolveVarOrField(token_index_, *CurrentLiteral());
+        expr = ResolveVarOrField(TokenIndex(), *CurrentLiteral());
         ASSERT(!expr->IsPrimaryNode());
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
         expr = ParseExpr(kAllowConst);
         ExpectToken(Token::kINTERPOL_END);
       }
       // Check if this interpolated string is still considered a compile time
       // constant. If it is we need to evaluate if the current string part is
@@ skipping 49 matching lines @@
     ConsumeToken();
     if ((CurrentToken() != Token::kINTERPOL_VAR) &&
         (CurrentToken() != Token::kINTERPOL_START)) {
       break;
     }
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
            (CurrentToken() == Token::kINTERPOL_START)) {
       if (CurrentToken() == Token::kINTERPOL_START) {
         ConsumeToken();
         if (IsIdentifier()) {
-          resolved_name = ResolveImportVar(token_index_, *CurrentLiteral());
+          resolved_name = ResolveImportVar(TokenIndex(), *CurrentLiteral());
           result = String::Concat(result, resolved_name);
           ConsumeToken();
           if (CurrentToken() != Token::kINTERPOL_END) {
             ErrorMsg("'}' expected");
           }
           ConsumeToken();
         } else {
           ErrorMsg("identifier expected");
         }
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_VAR);
-        resolved_name = ResolveImportVar(token_index_, *CurrentLiteral());
+        resolved_name = ResolveImportVar(TokenIndex(), *CurrentLiteral());
         result = String::Concat(result, resolved_name);
         ConsumeToken();
       }
     }
     // A string literal always ends with a kSTRING token.
     ASSERT(CurrentToken() == Token::kSTRING);
   }
   return &result;
 }
 
@@ skipping 14 matching lines @@
     if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
         // Check whether the identifier is a type parameter. Type parameters
         // can never be used as part of primary expressions.
         const Class& scope_class = Class::Handle(TypeParametersScopeClass());
         if (!scope_class.IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
               scope_class.LookupTypeParameter(*(qual_ident.ident),
-                                              token_index_));
+                                              TokenIndex()));
           if (!type_param.IsNull()) {
             String& type_param_name = String::Handle(type_param.Name());
             ErrorMsg(qual_ident.ident_pos,
                      "illegal use of type parameter %s",
                      type_param_name.ToCString());
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
         primary = ResolveIdentInLibraryScope(library_,
                                              qual_ident,
                                              kResolveIncludingImports);
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
       primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
                                                  qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     const String& this_name = String::Handle(String::NewSymbol(kThisName));
     LocalVariable* local = LookupLocalScope(this_name);
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
-    primary = new LoadLocalNode(token_index_, *local);
+    primary = new LoadLocalNode(TokenIndex(), *local);
     ConsumeToken();
   } else if (CurrentToken() == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
-    primary = new LiteralNode(token_index_, literal);
+    primary = new LiteralNode(TokenIndex(), literal);
     ConsumeToken();
   } else if (CurrentToken() == Token::kTRUE) {
-    primary = new LiteralNode(token_index_, Bool::ZoneHandle(Bool::True()));
+    primary = new LiteralNode(TokenIndex(), Bool::ZoneHandle(Bool::True()));
     ConsumeToken();
   } else if (CurrentToken() == Token::kFALSE) {
-    primary = new LiteralNode(token_index_, Bool::ZoneHandle(Bool::False()));
+    primary = new LiteralNode(TokenIndex(), Bool::ZoneHandle(Bool::False()));
     ConsumeToken();
   } else if (CurrentToken() == Token::kNULL) {
-    primary = new LiteralNode(token_index_, Instance::ZoneHandle());
+    primary = new LiteralNode(TokenIndex(), Instance::ZoneHandle());
     ConsumeToken();
   } else if (CurrentToken() == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (CurrentToken() == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
-    primary = new LiteralNode(token_index_, double_value);
+    primary = new LiteralNode(TokenIndex(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
     primary = ParseStringLiteral();
   } else if (CurrentToken() == Token::kNEW) {
     primary = ParseNewOperator();
   } else if (CurrentToken() == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
         (LookaheadToken(1) == Token::kLBRACE)) {
@@ skipping 311 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart