Speed up parsing w/ grammar shortcut.

src/parsing/parser-base.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 1532 matching lines @@
   switch (peek()) {
     case Token::THIS: {
       BindingPatternUnexpectedToken(classifier);
       Consume(Token::THIS);
       return this->ThisExpression(scope(), factory(), beg_pos);
     }
 
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
-      BindingPatternUnexpectedToken(classifier);
-      return this->ExpressionFromLiteral(Next(), beg_pos, scanner(), factory());

[vogelheim, 2016/07/28 09:35:01]

[drive-by cleanup]

     case Token::SMI:
     case Token::NUMBER:
       BindingPatternUnexpectedToken(classifier);
       return this->ExpressionFromLiteral(Next(), beg_pos, scanner(), factory());
 
     case Token::ASYNC:
       if (allow_harmony_async_await() &&
           !scanner()->HasAnyLineTerminatorAfterNext() &&
           PeekAhead() == Token::FUNCTION) {
         Consume(Token::ASYNC);
@@ skipping 705 matching lines @@
 
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
                                               ExpressionClassifier* classifier,
                                               bool* ok) {
+  // Parser shortcut: The following scope is a micro-optimization to reduce

[marja, 2016/07/28 10:01:28]

Can you put all this into a separate function, just to keep
ParseAssignmentExpression short?

So ParseAssignmentExpression would begin with:

if (RV* v = ParseAssignmentExpressionShortcut()) {
 return v;
}

[vogelheim, 2016/07/28 12:54:59]

Done.

The hardest part was to figure out how to test for an empty ExpressionT. :-/

I also changed the name to ParseTrivialAssignmentExpression, which is probably a
better description of what this does.

+  // parsing time and should be functionally neutral. When we encounter
+  //   [SMI|NUMBER|{NULL,TRUE,FALSE}_LITERAL|THIS|STRING|IDENTIFIER]
+  // followed by
+  //    [COMMA|RPAREN|RBRACK|SEMICOLON]
+  // then this will result in a single AST node. Instead of parsing this
+  // 'properly' (a call chain 11-levels deep), we will just generate the
+  // appropriate AST nodes right here.
+  {
+    Token::Value peek_token = peek();
+    bool is_number = peek_token == Token::SMI || peek_token == Token::NUMBER;
+    bool is_literal = peek_token == Token::NULL_LITERAL ||
+                      peek_token == Token::TRUE_LITERAL ||
+                      peek_token == Token::FALSE_LITERAL;
+    bool is_string = peek_token == Token::STRING;
+    bool is_identifier = peek_token == Token::IDENTIFIER;
+    bool is_this = peek_token == Token::THIS;
+    if (is_number || is_literal || is_string || is_identifier || is_this) {
+      // PeekAhead() is expensive & may not always be called, so we only call it
+      // after checking peek().
+      Token::Value peek_ahead = PeekAhead();
+      if (peek_ahead == Token::COMMA || peek_ahead == Token::RPAREN ||
+          peek_ahead == Token::SEMICOLON || peek_ahead == Token::RBRACK) {
+        Scanner::Location pos = scanner()->peek_location();
+        if (is_string) {
+          FuncNameInferrer::State fni_state(fni_);
+          classifier->RecordBindingPatternError(
+              pos, MessageTemplate::kUnexpectedTokenString);
+          Consume(Token::STRING);
+          return this->ExpressionFromString(pos.beg_pos, scanner(), factory());
+        } else if (is_this) {
+          classifier->RecordBindingPatternError(
+              pos, MessageTemplate::kUnexpectedToken, Token::Name(Token::THIS));
+          Consume(Token::THIS);
+          return this->ThisExpression(scope(), factory(), pos.beg_pos);
+        } else if (is_number) {
+          classifier->RecordBindingPatternError(
+              pos, MessageTemplate::kUnexpectedTokenNumber);
+          Consume(peek_token);
+          return this->ExpressionFromLiteral(peek_token, pos.beg_pos, scanner(),
+                                             factory());
+        } else if (is_literal) {
+          classifier->RecordBindingPatternError(
+              pos, MessageTemplate::kUnexpectedToken, Token::Name(peek_token));
+          Consume(peek_token);
+          return this->ExpressionFromLiteral(peek_token, pos.beg_pos, scanner(),
+                                             factory());
+        } else if (is_identifier) {
+          FuncNameInferrer::State fni_state(fni_);

[marja, 2016/07/28 10:01:29]

I don't understand the expression classifying stuff, so no idea if this is
correct or not. Relaying this part to adamk@.

+          ExpressionClassifier arrow_formals_classifier(
+              this, classifier->duplicate_finder());
+          IdentifierT name =
+              ParseAndClassifyIdentifier(&arrow_formals_classifier, CHECK_OK);
+          typename ParserBase<Traits>::ExpressionT shortcut_result =
+              this->ExpressionFromIdentifier(name, pos.beg_pos, pos.end_pos,
+                                             scope(), factory());
+          if (this->IsAssignableIdentifier(shortcut_result)) {
+            arrow_formals_classifier.ForgiveAssignmentPatternError();
+          }
+          classifier->Accumulate(
+              &arrow_formals_classifier,
+              ExpressionClassifier::StandardProductions |
+                  ExpressionClassifier::FormalParametersProductions |
+                  ExpressionClassifier::CoverInitializedNameProduction |
+                  ExpressionClassifier::AsyncArrowFormalParametersProduction |
+                  ExpressionClassifier::AsyncBindingPatternProduction,
+              false);
+          DCHECK(!Token::IsAssignmentOp(peek_ahead));
+          classifier->MergeNonPatterns(&arrow_formals_classifier);
+          return shortcut_result;
+        } else {
+          UNREACHABLE();
+        }
+      }
+    }
+    // No applicable shortcut found: Proceed w/ regular parsing.
+  }
+
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
   bool is_destructuring_assignment = false;
   int lhs_beg_pos = peek_position();
 
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(accept_IN, classifier, ok);
@@ skipping 1407 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H