Prohibit let in lexical bindings

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 17 matching lines @@
 
   enum TargetProduction {
     ExpressionProduction = 1 << 0,
     FormalParameterInitializerProduction = 1 << 1,
     BindingPatternProduction = 1 << 2,
     AssignmentPatternProduction = 1 << 3,
     DistinctFormalParametersProduction = 1 << 4,
     StrictModeFormalParametersProduction = 1 << 5,
     StrongModeFormalParametersProduction = 1 << 6,
     ArrowFormalParametersProduction = 1 << 7,
+    LetPatternProduction = 1 << 8,
 
     ExpressionProductions =
         (ExpressionProduction | FormalParameterInitializerProduction),
-    PatternProductions =
-        (BindingPatternProduction | AssignmentPatternProduction),
+    PatternProductions = (BindingPatternProduction |
+                          AssignmentPatternProduction | LetPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction |
                                    StrongModeFormalParametersProduction),
     StandardProductions = ExpressionProductions | PatternProductions,
     AllProductions = (StandardProductions | FormalParametersProductions |
                       ArrowFormalParametersProduction)
   };
 
   enum FunctionProperties { NonSimpleParameter = 1 << 0 };
 
@@ skipping 40 matching lines @@
   bool is_valid_strict_mode_formal_parameters() const {
     return is_valid(StrictModeFormalParametersProduction);
   }
 
   // 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);
   }
 
+  bool is_valid_let_pattern() const { return is_valid(LetPatternProduction); }
+
   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_;
   }
 
   const Error& duplicate_formal_parameter_error() const {
     return duplicate_formal_parameter_error_;
   }
 
   const Error& strict_mode_formal_parameter_error() const {
     return strict_mode_formal_parameter_error_;
   }
 
   const Error& strong_mode_formal_parameter_error() const {
     return strong_mode_formal_parameter_error_;
   }
 
+  const Error& let_pattern_error() const { return let_pattern_error_; }
+
   bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
   }
 
   void RecordNonSimpleParameter() {
     function_properties_ |= NonSimpleParameter;
   }
 
   void RecordExpressionError(const Scanner::Location& loc,
                              MessageTemplate::Template message,
@@ skipping 69 matching lines @@
   void RecordStrongModeFormalParameterError(const Scanner::Location& loc,
                                             MessageTemplate::Template message,
                                             const char* arg = nullptr) {
     if (!is_valid_strong_mode_formal_parameters()) return;
     invalid_productions_ |= StrongModeFormalParametersProduction;
     strong_mode_formal_parameter_error_.location = loc;
     strong_mode_formal_parameter_error_.message = message;
     strong_mode_formal_parameter_error_.arg = arg;
   }
 
+  void RecordLetPatternError(const Scanner::Location& loc,
+                             MessageTemplate::Template message,
+                             const char* arg = nullptr) {
+    if (!is_valid_let_pattern()) return;
+    invalid_productions_ |= LetPatternProduction;
+    let_pattern_error_.location = loc;
+    let_pattern_error_.message = message;
+    let_pattern_error_.arg = arg;
+  }
+
   void Accumulate(const ExpressionClassifier& inner,
                   unsigned productions = StandardProductions) {
     // 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 == 0) return;
     unsigned non_arrow_productions =
         productions & ~ArrowFormalParametersProduction;
     unsigned errors =
@@ skipping 40 matching lines @@
   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_;
+  Error let_pattern_error_;
   DuplicateFinder* duplicate_finder_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_EXPRESSION_CLASSIFIER_H