Disallow yield in default parameter initializers

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/messages.h"
 #include "src/scanner.h"
 #include "src/token.h"
@@ skipping 10 matching lines @@
           message(MessageTemplate::kNone),
           arg(nullptr) {}
 
     Scanner::Location location;
     MessageTemplate::Template message;
     const char* arg;
   };
 
   enum TargetProduction {
     ExpressionProduction = 1 << 0,
-    BindingPatternProduction = 1 << 1,
-    AssignmentPatternProduction = 1 << 2,
-    DistinctFormalParametersProduction = 1 << 3,
-    StrictModeFormalParametersProduction = 1 << 4,
-    StrongModeFormalParametersProduction = 1 << 5,
-    ArrowFormalParametersProduction = 1 << 6,
+    FormalParameterInitializerProduction = 1 << 1,
+    BindingPatternProduction = 1 << 2,
+    AssignmentPatternProduction = 1 << 3,
+    DistinctFormalParametersProduction = 1 << 4,
+    StrictModeFormalParametersProduction = 1 << 5,
+    StrongModeFormalParametersProduction = 1 << 6,
+    ArrowFormalParametersProduction = 1 << 7,
 
+    ExpressionProductions =
+        (ExpressionProduction | FormalParameterInitializerProduction),
     PatternProductions =
         (BindingPatternProduction | AssignmentPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction |
                                    StrongModeFormalParametersProduction),
-    StandardProductions = ExpressionProduction | PatternProductions,
+    StandardProductions = ExpressionProductions | PatternProductions,
     AllProductions = (StandardProductions | FormalParametersProductions |
                       ArrowFormalParametersProduction)
   };
 
   enum FunctionProperties { NonSimpleParameter = 1 << 0 };
 
   ExpressionClassifier()
       : invalid_productions_(0),
         function_properties_(0),
         duplicate_finder_(nullptr) {}
 
   explicit ExpressionClassifier(DuplicateFinder* duplicate_finder)
       : invalid_productions_(0),
         function_properties_(0),
         duplicate_finder_(duplicate_finder) {}
 
   bool is_valid(unsigned productions) const {
     return (invalid_productions_ & productions) == 0;
   }
 
   DuplicateFinder* duplicate_finder() const { return duplicate_finder_; }
 
   bool is_valid_expression() const { return is_valid(ExpressionProduction); }
 
+  bool is_valid_formal_parameter_initializer() const {
+    return is_valid(FormalParameterInitializerProduction);
+  }
+
   bool is_valid_binding_pattern() const {
     return is_valid(BindingPatternProduction);
   }
 
   bool is_valid_assignment_pattern() const {
     return is_valid(AssignmentPatternProduction);
   }
 
   bool is_valid_arrow_formal_parameters() const {
     return is_valid(ArrowFormalParametersProduction);
@@ skipping 10 matching lines @@
   }
 
   // Note: callers should also check is_valid_strict_mode_formal_parameters()
   // and is_valid_formal_parameter_list_without_duplicates().
   bool is_valid_strong_mode_formal_parameters() const {
     return is_valid(StrongModeFormalParametersProduction);
   }
 
   const Error& expression_error() const { return expression_error_; }
 
+  const Error& formal_parameter_initializer_error() const {
+    return formal_parameter_initializer_error_;
+  }
+
   const Error& binding_pattern_error() const { return binding_pattern_error_; }
 
   const Error& assignment_pattern_error() const {
     return assignment_pattern_error_;
   }
 
   const Error& arrow_formal_parameters_error() const {
     return arrow_formal_parameters_error_;
   }
 
@@ skipping 20 matching lines @@
   void RecordExpressionError(const Scanner::Location& loc,
                              MessageTemplate::Template message,
                              const char* arg = nullptr) {
     if (!is_valid_expression()) return;
     invalid_productions_ |= ExpressionProduction;
     expression_error_.location = loc;
     expression_error_.message = message;
     expression_error_.arg = arg;
   }
 
+  void RecordFormalParameterInitializerError(const Scanner::Location& loc,
+                                             MessageTemplate::Template message,
+                                             const char* arg = nullptr) {
+    if (!is_valid_formal_parameter_initializer()) return;
+    invalid_productions_ |= FormalParameterInitializerProduction;
+    formal_parameter_initializer_error_.location = loc;
+    formal_parameter_initializer_error_.message = message;
+    formal_parameter_initializer_error_.arg = arg;
+  }
+
   void RecordBindingPatternError(const Scanner::Location& loc,
                                  MessageTemplate::Template message,
                                  const char* arg = nullptr) {
     if (!is_valid_binding_pattern()) return;
     invalid_productions_ |= BindingPatternProduction;
     binding_pattern_error_.location = loc;
     binding_pattern_error_.message = message;
     binding_pattern_error_.arg = arg;
   }
 
@@ skipping 57 matching lines @@
     if (non_arrow_inner_invalid_productions == 0) return;
     unsigned non_arrow_productions =
         productions & ~ArrowFormalParametersProduction;
     unsigned errors =
         non_arrow_productions & non_arrow_inner_invalid_productions;
     errors &= ~invalid_productions_;
     if (errors != 0) {
       invalid_productions_ |= errors;
       if (errors & ExpressionProduction)
         expression_error_ = inner.expression_error_;
+      if (errors & FormalParameterInitializerProduction)
+        formal_parameter_initializer_error_ =
+            inner.formal_parameter_initializer_error_;
       if (errors & BindingPatternProduction)
         binding_pattern_error_ = inner.binding_pattern_error_;
       if (errors & AssignmentPatternProduction)
         assignment_pattern_error_ = inner.assignment_pattern_error_;
       if (errors & DistinctFormalParametersProduction)
         duplicate_formal_parameter_error_ =
             inner.duplicate_formal_parameter_error_;
       if (errors & StrictModeFormalParametersProduction)
         strict_mode_formal_parameter_error_ =
             inner.strict_mode_formal_parameter_error_;
@@ skipping 14 matching lines @@
         invalid_productions_ |= ArrowFormalParametersProduction;
         arrow_formal_parameters_error_ = inner.binding_pattern_error_;
       }
     }
   }
 
  private:
   unsigned invalid_productions_;
   unsigned function_properties_;
   Error expression_error_;
+  Error formal_parameter_initializer_error_;
   Error binding_pattern_error_;
   Error assignment_pattern_error_;
   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