Optimization: Saves 30M instructions on x64 parsing ~6MB of JS code in parser-shell

src/parsing/expression-classifier.h

 // Copyright 2015 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_EXPRESSION_CLASSIFIER_H
 #define V8_PARSING_EXPRESSION_CLASSIFIER_H
 
 #include "src/messages.h"
 #include "src/parsing/scanner.h"
 #include "src/parsing/token.h"
 
 namespace v8 {
 namespace internal {
 
 
 template <typename Traits>
 class ExpressionClassifier {
  public:
   struct Error {
-    Error()
-        : location(Scanner::Location::invalid()),
-          message(MessageTemplate::kNone),
-          type(kSyntaxError),
-          arg(nullptr) {}
+    Error() { reset(); }
 
     Scanner::Location location;
     MessageTemplate::Template message : 30;
     ParseErrorType type : 2;
     const char* arg;
+
+    V8_INLINE void reset() {
+        location.beg_pos = location.end_pos = -1;
+        message = MessageTemplate::kNone;
+        type = kSyntaxError;
+        arg = nullptr;
+    }
   };
 
   enum TargetProduction {
     ExpressionProduction = 1 << 0,
     FormalParameterInitializerProduction = 1 << 1,
     BindingPatternProduction = 1 << 2,
     AssignmentPatternProduction = 1 << 3,
     DistinctFormalParametersProduction = 1 << 4,
     StrictModeFormalParametersProduction = 1 << 5,
     ArrowFormalParametersProduction = 1 << 6,
@@ skipping 273 matching lines @@
                                      const char* arg = nullptr) {
     if (has_tail_call_expression()) return;
     invalid_productions_ |= TailCallExpressionProduction;
     tail_call_expression_error_.location = loc;
     tail_call_expression_error_.message = message;
     tail_call_expression_error_.arg = arg;
   }
 
   void ForgiveCoverInitializedNameError() {
     invalid_productions_ &= ~CoverInitializedNameProduction;
-    cover_initialized_name_error_ = Error();
+    cover_initialized_name_error_.reset();
   }
 
   void ForgiveAssignmentPatternError() {
     invalid_productions_ &= ~AssignmentPatternProduction;
-    assignment_pattern_error_ = Error();
+    assignment_pattern_error_.reset();
   }
 
   void Accumulate(ExpressionClassifier* inner,
                   unsigned productions = StandardProductions,
                   bool merge_non_patterns = true) {
     if (merge_non_patterns) MergeNonPatterns(inner);
     // Propagate errors from inner, but don't overwrite already recorded
     // errors.
     unsigned non_arrow_inner_invalid_productions =
         inner->invalid_productions_ & ~ArrowFormalParametersProduction;
@@ skipping 81 matching lines @@
   Error async_arrow_formal_parameters_error_;
   Error async_binding_pattern_error_;
   DuplicateFinder* duplicate_finder_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H