Simpler implementation of expression classifiers

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"
@@ skipping 353 matching lines @@
     Error& e = reported_error(kAssignmentPatternProduction);
     e.kind = kUnusedError;
   }
 
   void Accumulate(ExpressionClassifier* inner,
                   unsigned productions = StandardProductions,
                   bool merge_non_patterns = true) {
     DCHECK_EQ(inner->reported_errors_, reported_errors_);
     DCHECK_EQ(inner->reported_errors_begin_, reported_errors_end_);
     DCHECK_EQ(inner->reported_errors_end_, reported_errors_->length());
+
     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;
-    if (non_arrow_inner_invalid_productions) {
-      unsigned errors = non_arrow_inner_invalid_productions & productions &
-                        ~invalid_productions_;
-      // As an exception to the above, the result continues to be a valid arrow
-      // formal parameters if the inner expression is a valid binding pattern.
-      if (productions & ArrowFormalParametersProduction &&
-          is_valid_arrow_formal_parameters()) {
-        // Also copy function properties if expecting an arrow function
-        // parameter.
-        function_properties_ |= inner->function_properties_;
 
-        if (!inner->is_valid_binding_pattern())
-          errors |= ArrowFormalParametersProduction;
-      }
+    // Propagate errors from inner, excluding arrow formal parameters.
+    unsigned errors = inner->invalid_productions_ & productions &
+                      ~ArrowFormalParametersProduction;
+    bool keep_inner = errors & ~invalid_productions_;
+    bool copy_arrow = false;
 
-      if (errors != 0) {
-        invalid_productions_ |= errors;
-        int arrow_index = inner->reported_errors_end_;
-        for (int i = inner->reported_errors_begin_;
-             i < inner->reported_errors_end_; i++) {
-          if (reported_errors_->at(i).kind == kUnusedError ||
-              reported_errors_->at(i).kind == kArrowFormalParametersProduction)
-            continue;
-          if (errors & (1 << reported_errors_->at(i).kind))
-            Move(i);
-          if (reported_errors_->at(i).kind == kBindingPatternProduction &&
-              errors & ArrowFormalParametersProduction) {
-            if (reported_errors_end_ <= i) {
-              Move(i);
-              reported_errors_->at(reported_errors_end_-1).kind =
-                  kArrowFormalParametersProduction;
-            } else {
-              DCHECK_EQ(reported_errors_end_, i+1);
-              arrow_index = i;
-            }
-          }
-        }
-        if (arrow_index < inner->reported_errors_end_) {
-          if (reported_errors_end_ < inner->reported_errors_end_) {
-            Replace(reported_errors_end_, arrow_index);
-            reported_errors_->at(reported_errors_end_++).kind =
-                kArrowFormalParametersProduction;
-          } else {
-            Add(reported_errors_->at(arrow_index));
-            reported_errors_->at(reported_errors_end_-1).kind =
-                kArrowFormalParametersProduction;
-          }
-        }
+    // If there's nothing to add, the inner classifier's array can be dropped.
+    if (keep_inner) invalid_productions_ |= errors;
+
+    // As an exception to error propagation, the result continues to be valid
+    // as arrow formal parameters if the inner expression is a valid binding
+    // pattern.
+    if (productions & ArrowFormalParametersProduction &&
+        is_valid_arrow_formal_parameters()) {
+      // Also copy function properties if expecting an arrow function
+      // parameter.
+      function_properties_ |= inner->function_properties_;
+      if (!inner->is_valid_binding_pattern()) {
+        keep_inner = copy_arrow = true;
+        invalid_productions_ |= ArrowFormalParametersProduction;
       }
     }
-    reported_errors_->Rewind(reported_errors_end_);
+
+    if (keep_inner) {
+      reported_errors_end_ = inner->reported_errors_end_;
+      if (copy_arrow) {
+        Add(inner->reported_error(kBindingPatternProduction));
+        reported_errors_->at(reported_errors_end_-1).kind =
+            kArrowFormalParametersProduction;
+      }
+    } else {
+      reported_errors_->Rewind(reported_errors_end_);
+    }
+
     inner->reported_errors_begin_ = inner->reported_errors_end_ =
         reported_errors_end_;
   }
 
   V8_INLINE int GetNonPatternBegin() const { return non_pattern_begin_; }
 
   V8_INLINE void Discard() {
     if (reported_errors_end_ == reported_errors_->length()) {
       reported_errors_->Rewind(reported_errors_begin_);
       reported_errors_end_ = reported_errors_begin_;
@@ skipping 22 matching lines @@
     static Error none;
     return none;
   }
 
   V8_INLINE void Add(const Error& e) {
     DCHECK_EQ(reported_errors_end_, reported_errors_->length());
     reported_errors_->Add(e, zone_);
     reported_errors_end_++;
   }
 
-  V8_INLINE void Move(int i) {
-    DCHECK_LE(reported_errors_end_, i);
-    DCHECK_LT(i, reported_errors_->length());
-    if (reported_errors_end_ < i)
-      reported_errors_->at(reported_errors_end_) = reported_errors_->at(i);
-    reported_errors_end_++;
-  }
-
-  V8_INLINE void Replace(int j, int i) {
-    DCHECK_LT(i, reported_errors_->length());
-    DCHECK_LE(j, reported_errors_end_);
-    DCHECK(j == reported_errors_end_ ||
-           reported_errors_->at(j).kind == kUnusedError);
-    if (i != j) reported_errors_->at(j) = reported_errors_->at(i);
-  }
-
   Zone* zone_;
   ZoneList<typename Traits::Type::Expression>* non_patterns_to_rewrite_;
   int non_pattern_begin_;
   unsigned invalid_productions_ : 14;
   unsigned function_properties_ : 2;
   ZoneList<Error>* reported_errors_;
   int reported_errors_begin_;
   int reported_errors_end_;
   DuplicateFinder* duplicate_finder_;
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H