Speed up parsing w/ grammar shortcut.

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 182 matching lines @@
         TypeField::encode(kExpression) |
         ExpressionTypeField::encode(kSuperCallReference));
   }
 
   static PreParserExpression NoTemplateTag() {
     return PreParserExpression(
         TypeField::encode(kExpression) |
         ExpressionTypeField::encode(kNoTemplateTagExpression));
   }
 
+  static PreParserExpression Empty() {
+    return PreParserExpression(TypeField::encode(kExpression) |
+                               ExpressionTypeField::encode(kEmptyExpression));
+  }
+
   bool IsIdentifier() const {
     return TypeField::decode(code_) == kIdentifierExpression;
   }
 
+  bool IsEmptyExpression() const {
+    return TypeField::decode(code_) == kExpression &&
+           ExpressionTypeField::decode(code_) == kEmptyExpression;
+  }
+
   PreParserIdentifier AsIdentifier() const {
     DCHECK(IsIdentifier());
     return PreParserIdentifier(IdentifierTypeField::decode(code_));
   }
 
   bool IsAssignment() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kAssignment;
   }
 
@@ skipping 92 matching lines @@
   };
 
   enum ExpressionType {
     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kCallEvalExpression,
     kSuperCallReference,
     kNoTemplateTagExpression,
-    kAssignment
+    kAssignment,
+    kEmptyExpression
   };
 
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
   // The first three bits are for the Type.
   typedef BitField<Type, 0, 3> TypeField;
 
   // The high order bit applies only to nodes which would inherit from the
   // Expression ASTNode --- This is by necessity, due to the fact that
   // Expression nodes may be represented as multiple Types, not exclusively
   // through kExpression.
   // TODO(caitp, adamk): clean up PreParserExpression bitfields.
   typedef BitField<bool, 31, 1> ParenthesizedField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.
-  typedef BitField<ExpressionType, TypeField::kNext, 3> ExpressionTypeField;
+  typedef BitField<ExpressionType, TypeField::kNext, 4> ExpressionTypeField;
   typedef BitField<bool, TypeField::kNext, 1> IsUseStrictField;
   typedef BitField<PreParserIdentifier::Type, TypeField::kNext, 10>
       IdentifierTypeField;
   typedef BitField<bool, TypeField::kNext, 1> HasCoverInitializedNameField;
 
   uint32_t code_;
 };
 
 
 // The pre-parser doesn't need to build lists of expressions, identifiers, or
@@ skipping 307 matching lines @@
 
   // Returns true if the expression is of type "this.foo".
   static bool IsThisProperty(PreParserExpression expression) {
     return expression.IsThisProperty();
   }
 
   static bool IsIdentifier(PreParserExpression expression) {
     return expression.IsIdentifier();
   }
 
+  static bool IsEmptyExpression(PreParserExpression expression) {
+    return expression.IsEmptyExpression();
+  }
+
   static PreParserIdentifier AsIdentifier(PreParserExpression expression) {
     return expression.AsIdentifier();
   }
 
   static bool IsEvalIdentifier(PreParserExpression expression) {
     return IsIdentifier(expression) && IsEval(AsIdentifier(expression));
   }
 
   static bool IsDirectEvalCall(PreParserExpression expression) {
     return expression.IsDirectEvalCall();
@@ skipping 90 matching lines @@
   static void Void() {}
 
   // "null" return type creators.
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
   static PreParserIdentifier EmptyIdentifierString() {
     return PreParserIdentifier::Default();
   }
   static PreParserExpression EmptyExpression() {
-    return PreParserExpression::Default();
+    return PreParserExpression::Empty();
   }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyFunctionLiteral() {
     return PreParserExpression::Default();
   }
@@ skipping 481 matching lines @@
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H