Cache the current token in some functions in the parser

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 3040 matching lines @@
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
 }
 
 
 // Skips tokens up to matching closing parenthesis.
 void Parser::SkipToMatchingParenthesis() {
-  ASSERT(CurrentToken() == Token::kLPAREN);
+  Token::Kind current_token = CurrentToken();
+  ASSERT(current_token == Token::kLPAREN);
   int level = 0;
   do {
-    if (CurrentToken() == Token::kLPAREN) {
+    if (current_token == Token::kLPAREN) {
       level++;
-    } else if (CurrentToken() == Token::kRPAREN) {
+    } else if (current_token == Token::kRPAREN) {
       level--;
     }
     ConsumeToken();
-  } while ((level > 0) && (CurrentToken() != Token::kEOS));
+    current_token = CurrentToken();
+  } while ((level > 0) && (current_token != Token::kEOS));
 }
 
 
 void Parser::SkipInitializers() {
   ASSERT(CurrentToken() == Token::kCOLON);
   do {
     ConsumeToken();  // Colon or comma.
     if (CurrentToken() == Token::kSUPER) {
       ConsumeToken();
       if (CurrentToken() == Token::kPERIOD) {
@@ skipping 4244 matching lines @@
     if (LookaheadToken(1) == Token::kCOLON) {
       // Statement starts with a label.
       label_name = CurrentLiteral();
       label_pos = TokenPos();
       ASSERT(label_pos > 0);
       ConsumeToken();  // Consume identifier.
       ConsumeToken();  // Consume colon.
     }
   }
   const intptr_t statement_pos = TokenPos();
+  const Token::Kind token = CurrentToken();
 
-  if (CurrentToken() == Token::kWHILE) {
+  if (token == Token::kWHILE) {
     statement = ParseWhileStatement(label_name);
-  } else if (CurrentToken() == Token::kFOR) {
+  } else if (token == Token::kFOR) {
     statement = ParseForStatement(label_name);
-  } else if (CurrentToken() == Token::kDO) {
+  } else if (token == Token::kDO) {
     statement = ParseDoWhileStatement(label_name);
-  } else if (CurrentToken() == Token::kSWITCH) {
+  } else if (token == Token::kSWITCH) {
     statement = ParseSwitchStatement(label_name);
-  } else if (CurrentToken() == Token::kTRY) {
+  } else if (token == Token::kTRY) {
     statement = ParseTryStatement(label_name);
-  } else if (CurrentToken() == Token::kRETURN) {
+  } else if (token == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     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, kConsumeCascades);
       statement = new(isolate()) ReturnNode(statement_pos, expr);
     } else {
       statement = new(isolate()) ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
-  } else if (CurrentToken() == Token::kIF) {
+  } else if (token == Token::kIF) {
     statement = ParseIfStatement(label_name);
-  } else if (CurrentToken() == Token::kASSERT) {
+  } else if (token == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
     ExpectSemicolon();
   } else if (IsFunctionDeclaration()) {
     statement = ParseFunctionStatement(false);
-  } else if (CurrentToken() == Token::kLBRACE) {
+  } else if (token == Token::kLBRACE) {
     SourceLabel* label = NULL;
     OpenBlock();
     if (label_name != NULL) {
       label = SourceLabel::New(label_pos, label_name, SourceLabel::kStatement);
       current_block_->scope->AddLabel(label);
     }
     ConsumeToken();
     ParseStatementSequence();
     statement = CloseBlock();
     if (label != NULL) {
       statement->AsSequenceNode()->set_label(label);
     }
     ExpectToken(Token::kRBRACE);
-  } else if (CurrentToken() == Token::kBREAK) {
+  } else if (token == Token::kBREAK) {
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
-  } else if (CurrentToken() == Token::kCONTINUE) {
+  } else if (token == Token::kCONTINUE) {
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
-  } else if (CurrentToken() == Token::kSEMICOLON) {
+  } else if (token == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
-  } else if (CurrentToken() == Token::kRETHROW) {
+  } else if (token == Token::kRETHROW) {
     // Rethrow of current exception.
     ConsumeToken();
     ExpectSemicolon();
     // Check if it is ok to do a rethrow.
     if ((try_blocks_list_ == NULL) || !try_blocks_list_->inside_catch()) {
       ErrorMsg(statement_pos, "rethrow of an exception is not valid here");
     }
     // The exception and stack trace variables are bound in the block
     // containing the try.
     LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
@@ skipping 3065 matching lines @@
     primary = new(isolate()) StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
 
 
 AstNode* Parser::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
+  const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     intptr_t qual_ident_pos = TokenPos();
     ParseQualIdent(&qual_ident);
@@ skipping 59 matching lines @@
                                            current_class(),
                                            qualified_name,
                                            NULL,  // No arguments.
                                            InvocationMirror::kTopLevel,
                                            call_type,
                                            NULL);  // No existing function.
         }
       }
     }
     ASSERT(primary != NULL);
-  } else if (CurrentToken() == Token::kTHIS) {
+  } else if (token == Token::kTHIS) {
     LocalVariable* local = LookupLocalScope(Symbols::This());
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
     primary = new(isolate()) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
-  } else if (CurrentToken() == Token::kINTEGER) {
+  } else if (token == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(I, CurrentIntegerLiteral());
     primary = new(isolate()) LiteralNode(TokenPos(), literal);
     ConsumeToken();
-  } else if (CurrentToken() == Token::kTRUE) {
+  } else if (token == Token::kTRUE) {
     primary = new(isolate()) LiteralNode(TokenPos(), Bool::True());
     ConsumeToken();
-  } else if (CurrentToken() == Token::kFALSE) {
+  } else if (token == Token::kFALSE) {
     primary = new(isolate()) LiteralNode(TokenPos(), Bool::False());
     ConsumeToken();
-  } else if (CurrentToken() == Token::kNULL) {
+  } else if (token == Token::kNULL) {
     primary = new(isolate()) LiteralNode(TokenPos(), Instance::ZoneHandle(I));
     ConsumeToken();
-  } else if (CurrentToken() == Token::kLPAREN) {
+  } else if (token == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
-  } else if (CurrentToken() == Token::kDOUBLE) {
+  } else if (token == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(I, CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
     primary = new(isolate()) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
-  } else if (CurrentToken() == Token::kSTRING) {
+  } else if (token == Token::kSTRING) {
     primary = ParseStringLiteral(true);
-  } else if (CurrentToken() == Token::kNEW) {
+  } else if (token == Token::kNEW) {
     ConsumeToken();
     primary = ParseNewOperator(Token::kNEW);
-  } else if (CurrentToken() == Token::kCONST) {
+  } else if (token == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
         (LookaheadToken(1) == Token::kLBRACE)) {
       primary = ParseCompoundLiteral();
     } else {
       ConsumeToken();
       primary = ParseNewOperator(Token::kCONST);
     }
-  } else if (CurrentToken() == Token::kLT ||
-             CurrentToken() == Token::kLBRACK ||
-             CurrentToken() == Token::kINDEX ||
-             CurrentToken() == Token::kLBRACE) {
+  } else if (token == Token::kLT ||
+             token == Token::kLBRACK ||
+             token == Token::kINDEX ||
+             token == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
-  } else if (CurrentToken() == Token::kHASH) {
+  } else if (token == Token::kHASH) {
     primary = ParseSymbolLiteral();
-  } else if (CurrentToken() == Token::kSUPER) {
+  } else if (token == Token::kSUPER) {
     if (parsing_metadata_) {
       ErrorMsg("cannot access superclass from metadata");
     }
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
       ErrorMsg("class '%s' does not have a superclass",
                String::Handle(isolate(), current_class().Name()).ToCString());
     }
@@ skipping 92 matching lines @@
     SkipExpr();
   }
 }
 
 
 // Skips function/method/constructor/getter/setter preambles until the formal
 // parameter list. It is enough to skip the tokens, since we have already
 // previously parsed the function.
 void Parser::SkipFunctionPreamble() {
   while (true) {
-    if (CurrentToken() == Token::kLPAREN ||
-        CurrentToken() == Token::kARROW ||
-        CurrentToken() == Token::kSEMICOLON ||
-        CurrentToken() == Token::kLBRACE) {
+    const Token::Kind token = CurrentToken();
+    if (token == Token::kLPAREN ||
+        token == Token::kARROW ||
+        token == Token::kSEMICOLON ||
+        token == Token::kLBRACE) {

[srdjan, 2014/05/28 02:25:13]

Add parentheses here and below.

       return;
     }
     // Case handles "native" keyword, but also return types of form
     // native.SomeType where native is the name of a library.
-    if (CurrentToken() == Token::kIDENT &&
-        LookaheadToken(1) != Token::kPERIOD) {
+    if (token == Token::kIDENT && LookaheadToken(1) != Token::kPERIOD) {
       if (CurrentLiteral()->raw() == Symbols::Native().raw()) {
         return;
       }
     }
     ConsumeToken();
   }
 }
 
 
 void Parser::SkipListLiteral() {
@@ skipping 166 matching lines @@
         UnexpectedToken();
         UNREACHABLE();
       }
       break;
   }
 }
 
 
 void Parser::SkipSelectors() {
   while (true) {
-    if (CurrentToken() == Token::kCASCADE) {
+    const Token::Kind current_token = CurrentToken();
+    if (current_token == Token::kCASCADE) {
       ConsumeToken();
       if (CurrentToken() == Token::kLBRACK) {
         continue;  // Consume [ in next loop iteration.
       } else {
         ExpectIdentifier("identifier or [ expected after ..");
       }
-    } else if (CurrentToken() == Token::kPERIOD) {
+    } else if (current_token == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
-    } else if (CurrentToken() == Token::kLBRACK) {
+    } else if (current_token == Token::kLBRACK) {
       ConsumeToken();
       SkipNestedExpr();
       ExpectToken(Token::kRBRACK);
-    } else if (CurrentToken() == Token::kLPAREN) {
+    } else if (current_token == Token::kLPAREN) {
       SkipActualParameters();
     } else {
       break;
     }
   }
 }
 
 void Parser::SkipPostfixExpr() {
   SkipPrimary();
   SkipSelectors();
@@ skipping 73 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart