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

vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "vm/ast.h"
@@ skipping 61 matching lines @@
     ASSERT(has_expression_temp_var());
     return expression_temp_var_;
   }
   void set_expression_temp_var(LocalVariable* value) {
     ASSERT(!has_expression_temp_var());
     expression_temp_var_ = value;
   }
   bool has_expression_temp_var() const {
     return expression_temp_var_ != NULL;
   }
-  static LocalVariable* CreateExpressionTempVar(intptr_t token_index);
+  static LocalVariable* CreateExpressionTempVar(intptr_t token_pos);
 
   int first_parameter_index() const { return first_parameter_index_; }
   int first_stack_local_index() const { return first_stack_local_index_; }
   int copied_parameter_count() const { return copied_parameter_count_; }
   int stack_local_count() const { return stack_local_count_; }
 
   void AllocateVariables();
 
  private:
   const Function& function_;
   SequenceNode* node_sequence_;
   AstNode* instantiator_;
   Array& default_parameter_values_;
   LocalVariable* saved_context_var_;
   LocalVariable* expression_temp_var_;
 
   int first_parameter_index_;
   int first_stack_local_index_;
   int copied_parameter_count_;
   int stack_local_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ParsedFunction);
 };
 
 
+// The class TokenStreamIterator encapsulates iteration over the TokenStream
+// object. The parser uses this to iterate over tokens while parsing a script
+// or a function.
+class TokenStreamIterator : ValueObject {
+ public:
+  TokenStreamIterator(const TokenStream& tokens, intptr_t token_pos)
+      : tokens_(tokens), token_position_(token_pos) { }
+
+  intptr_t NumberOfTokens() const { return tokens_.Length(); }
+  bool IsValid() const;
+
+  inline Token::Kind CurrentTokenKind() const;
+  Token::Kind LookaheadTokenKind(intptr_t num_tokens) const;
+
+  intptr_t CurrentPosition() const { return token_position_; }
+  void SetCurrentPosition(intptr_t value) { token_position_ = value; }
+
+  void Advance() { token_position_ += 1; }
+
+  RawObject* CurrentToken() const;
+  RawString* CurrentLiteral() const;
+
+ private:
+  const TokenStream& tokens_;
+  intptr_t token_position_;
+};
+
+
 class Parser : ValueObject {
  public:
   Parser(const Script& script, const Library& library);
-  Parser(const Script& script,
-         const Function& function,
-         intptr_t token_index);
+  Parser(const Script& script, const Function& function, intptr_t token_pos);
 
   // Parse the top level of a whole script file and register declared classes
   // and interfaces in the given library.
   static void ParseCompilationUnit(const Library& library,
                                    const Script& script);
 
   static void ParseFunction(ParsedFunction* parsed_function);
 
   // Build an error object containing a formatted error or warning message.
-  // A null script means no source and a negative token_index means no position.
+  // A null script means no source and a negative token_pos means no position.
   static RawError* FormatError(const Script& script,
-                               intptr_t token_index,
+                               intptr_t token_pos,
                                const char* message_header,
                                const char* format,
                                va_list args);
 
   // Same as FormatError, but appends the new error to the 'prev_error'.
   static RawError* FormatErrorWithAppend(const Error& prev_error,
                                          const Script& script,
-                                         intptr_t token_index,
+                                         intptr_t token_pos,
                                          const char* message_header,
                                          const char* format,
                                          va_list args);
 
  private:
   struct Block;
   class TryBlocks;
 
   // The function being parsed.
   const Function& current_function() const;
@@ skipping 19 matching lines @@
   // The class or interface being parsed.
   const Class& current_class() const;
   void set_current_class(const Class& value);
 
   // Parsing a library or a regular source script.
   bool is_library_source() const {
     return (script_.kind() == RawScript::kScript) ||
         (script_.kind() == RawScript::kLibrary);
   }
 
+  intptr_t TokenPos() const { return tokens_iterator_.CurrentPosition(); }
   inline Token::Kind CurrentToken();
   Token::Kind LookaheadToken(int num_tokens);
   String* CurrentLiteral() const;
   RawDouble* CurrentDoubleLiteral() const;
   RawInteger* CurrentIntegerLiteral() const;
 
   // Sets parser to given token position in the stream.
   void SetPosition(intptr_t position);
 
   void ConsumeToken() {
     // Reset cache and advance the token.
     token_kind_ = Token::kILLEGAL;
-    token_index_++;
+    tokens_iterator_.Advance();
     CompilerStats::num_tokens_consumed++;
   }
   void ConsumeRightAngleBracket();
   void ExpectToken(Token::Kind token_expected);
   void ExpectSemicolon();
   void UnexpectedToken();
   String* ExpectTypeIdentifier(const char* msg);
   String* ExpectIdentifier(const char* msg);
   bool IsLiteral(const char* literal);
 
@@ skipping 18 matching lines @@
   void SkipFunctionLiteral();
   void SkipStringLiteral();
   void SkipQualIdent();
 
   void CheckConstructorCallTypeArguments(
     intptr_t pos,
     Function& constructor,
     const AbstractTypeArguments& type_arguments);
 
   // Format an error or warning message into the message_buffer.
-  // A null script means no source and a negative token_index means no position.
+  // A null script means no source and a negative token_pos means no position.
   static void FormatMessage(const Script& script,
-                            intptr_t token_index,
+                            intptr_t token_pos,
                             const char* message_header,
                             char* message_buffer,
                             intptr_t message_buffer_size,
                             const char* format,
                             va_list args);
 
   // Reports error/warning message at location of current token.
   void ErrorMsg(const char* msg, ...);
   void Warning(const char* msg, ...);
   void Unimplemented(const char* msg);
 
   // Reports error message at given location.
-  void ErrorMsg(intptr_t token_index, const char* msg, ...);
-  void Warning(intptr_t token_index, const char* msg, ...);
+  void ErrorMsg(intptr_t token_pos, const char* msg, ...);
+  void Warning(intptr_t token_pos, const char* msg, ...);
 
   // Reports an already formatted error message.
   void ErrorMsg(const Error& error);
 
   // Concatenates two error messages, the previous and the current one.
   void AppendErrorMsg(
-      const Error& prev_error, intptr_t token_index, const char* format, ...);
+      const Error& prev_error, intptr_t token_pos, const char* format, ...);
 
   const Instance& EvaluateConstExpr(AstNode* expr);
   AstNode* RunStaticFieldInitializer(const Field& field);
   RawObject* EvaluateConstConstructorCall(
       const Class& type_class,
       const AbstractTypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
   AstNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
 
@@ skipping 80 matching lines @@
 
   void ChainNewBlock(LocalScope* outer_scope);
   void OpenBlock();
   void OpenLoopBlock();
   void OpenFunctionBlock(const Function& func);
   SequenceNode* CloseBlock();
 
   LocalVariable* LookupPhaseParameter();
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   void CaptureReceiver();
-  AstNode* LoadReceiver(intptr_t token_index);
+  AstNode* LoadReceiver(intptr_t token_pos);
   AstNode* LoadFieldIfUnresolved(AstNode* node);
   AstNode* LoadClosure(PrimaryNode* primary);
-  AstNode* CallGetter(intptr_t token_index,
-                      AstNode* object,
-                      const String& name);
+  AstNode* CallGetter(intptr_t token_pos, AstNode* object, const String& name);
 
   AstNode* ParseAssertStatement();
   AstNode* ParseJump(String* label_name);
   AstNode* ParseIfStatement(String* label_name);
   AstNode* ParseWhileStatement(String* label_name);
   AstNode* ParseDoWhileStatement(String* label_name);
   AstNode* ParseForStatement(String* label_name);
   AstNode* ParseForInStatement(intptr_t forin_pos, SourceLabel* label);
   CaseNode* ParseCaseClause(LocalVariable* switch_expr_value,
                             SourceLabel* case_label);
@@ skipping 94 matching lines @@
   RawString* ResolveImportVar(intptr_t ident_pos, const String& ident);
   AstNode* OptimizeBinaryOpNode(intptr_t op_pos,
                                 Token::Kind binary_op,
                                 AstNode* lhs,
                                 AstNode* rhs);
   AstNode* ExpandAssignableOp(intptr_t op_pos,
                               Token::Kind assignment_op,
                               AstNode* lhs,
                               AstNode* rhs);
   AstNode* PrepareCompoundAssignmentNodes(AstNode** expr);
-  LocalVariable* CreateTempConstVariable(intptr_t token_index,
+  LocalVariable* CreateTempConstVariable(intptr_t token_pos,
                                          intptr_t token_id,
                                          const char* s);
 
   static bool IsAssignableExpr(AstNode* expr);
 
   static bool IsPrefixOperator(Token::Kind token);
   static bool IsIncrementOperator(Token::Kind token);
 
   static SequenceNode* NodeAsSequenceNode(intptr_t sequence_pos,
                                           AstNode* node,
                                           LocalScope* scope);
 
   SequenceNode* MakeImplicitConstructor(const Function& func);
   AstNode* MakeStaticCall(const char* class_name,
                           const char* function_name,
                           ArgumentListNode* arguments);
   String& Interpolate(ArrayNode* values);
   AstNode* MakeAssertCall(intptr_t begin, intptr_t end);
   AstNode* ThrowTypeError(intptr_t type_pos, const AbstractType& type);
 
-  void CheckFunctionIsCallable(intptr_t token_index, const Function& function);
+  void CheckFunctionIsCallable(intptr_t token_pos, const Function& function);
   void CheckOperatorArity(const MemberDesc& member, Token::Kind operator_token);
 
   const LocalVariable& GetIncrementTempLocal();
   void EnsureExpressionTemp();
   AstNode* CreateAssignmentNode(AstNode* original, AstNode* rhs);
   AstNode* InsertClosureCallNodes(AstNode* condition);
 
   ConstructorCallNode* CreateConstructorCallNode(
-      intptr_t token_index,
+      intptr_t token_pos,
       const AbstractTypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
 
 
   const Script& script_;
-  const TokenStream& tokens_;
-  intptr_t token_index_;
-  Token::Kind token_kind_;  // Cached token kind for the token_index_.
+  TokenStreamIterator tokens_iterator_;
+  Token::Kind token_kind_;  // Cached token kind for current token.
   Block* current_block_;
 
   // is_top_level_ is true if parsing the "top level" of a compilation unit,
   // that is interface and class definitions.
   bool is_top_level_;
 
   // The member currently being parsed during "top level" parsing.
   MemberDesc* current_member_;
 
   // Parser mode to allow/disallow function literals. This is used in
@@ skipping 18 matching lines @@
 
   // Allocate temporary only once per function.
   LocalVariable* expression_temp_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_