Support rest parameters in arrow functions

src/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_EXPRESSION_CLASSIFIER_H
 #define V8_EXPRESSION_CLASSIFIER_H
 
 #include "src/v8.h"
 
 #include "src/messages.h"
@@ skipping 18 matching lines @@
   };
 
   enum TargetProduction {
     ExpressionProduction = 1 << 0,
     BindingPatternProduction = 1 << 1,
     AssignmentPatternProduction = 1 << 2,
     DistinctFormalParametersProduction = 1 << 3,
     StrictModeFormalParametersProduction = 1 << 4,
     StrongModeFormalParametersProduction = 1 << 5,
     ArrowFormalParametersProduction = 1 << 6,
+    // Unlike the others; see note in RecordArrowFormalParametersWithRest.
+    ArrowFormalParametersWithRestProduction = 1 << 7,

[Dmitry Lomov (no reviews), 2015/06/10 11:04:41]

I am not too happy about this irregularity. We aro no longer using the
classifier to report errors, but also to propagate information.

How about this: afaiu this bit is only used in parser, and parser can just
analyze the ASt directly to see if the last parameter is a spread operation or
not. WDYT?

[wingo, 2015/06/10 13:21:10]

Done.

 
     PatternProductions =
         (BindingPatternProduction | AssignmentPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction |
                                    StrongModeFormalParametersProduction),
     StandardProductions = ExpressionProduction | PatternProductions,
     AllProductions = (StandardProductions | FormalParametersProductions |
                       ArrowFormalParametersProduction)
   };
@@ skipping 17 matching lines @@
   }
 
   bool is_valid_assignment_pattern() const {
     return is_valid(AssignmentPatternProduction);
   }
 
   bool is_valid_arrow_formal_parameters() const {
     return is_valid(ArrowFormalParametersProduction);
   }
 
+  bool is_arrow_formal_parameters_with_rest() const {
+    return (invalid_productions_ & ArrowFormalParametersWithRestProduction) !=
+           0;
+  }
+
   bool is_valid_formal_parameter_list_without_duplicates() const {
     return is_valid(DistinctFormalParametersProduction);
   }
 
   // Note: callers should also check
   // is_valid_formal_parameter_list_without_duplicates().
   bool is_valid_strict_mode_formal_parameters() const {
     return is_valid(StrictModeFormalParametersProduction);
   }
 
@@ skipping 60 matching lines @@
   void RecordArrowFormalParametersError(const Scanner::Location& loc,
                                         MessageTemplate::Template message,
                                         const char* arg = nullptr) {
     if (!is_valid_arrow_formal_parameters()) return;
     invalid_productions_ |= ArrowFormalParametersProduction;
     arrow_formal_parameters_error_.location = loc;
     arrow_formal_parameters_error_.message = message;
     arrow_formal_parameters_error_.arg = arg;
   }
 
+  void RecordArrowFormalParametersWithRest() {
+    // Unlike the other TargetProduction flags,
+    // ArrowFormalParametersWithRestProduction indicates the presence of a rest
+    // parameter, not the presence of an error.  It doesn't propagate out via
+    // Accumulate() either, and doesn't have an associated location.
+    invalid_productions_ |= ArrowFormalParametersWithRestProduction;
+  }
+
   void RecordDuplicateFormalParameterError(const Scanner::Location& loc) {
     if (!is_valid_formal_parameter_list_without_duplicates()) return;
     invalid_productions_ |= DistinctFormalParametersProduction;
     duplicate_formal_parameter_error_.location = loc;
     duplicate_formal_parameter_error_.message =
         MessageTemplate::kStrictParamDupe;
     duplicate_formal_parameter_error_.arg = nullptr;
   }
 
   // Record a binding that would be invalid in strict mode.  Confusingly this
@@ skipping 80 matching lines @@
   Error arrow_formal_parameters_error_;
   Error duplicate_formal_parameter_error_;
   Error strict_mode_formal_parameter_error_;
   Error strong_mode_formal_parameter_error_;
   DuplicateFinder* duplicate_finder_;
 };
 }
 }  // v8::internal
 
 #endif  // V8_EXPRESSION_CLASSIFIER_H