[es6] conditionally ignore TDZ semantics for formals

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 30 matching lines @@
     PatternProductions =
         (BindingPatternProduction | AssignmentPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction |
                                    StrongModeFormalParametersProduction),
     StandardProductions = ExpressionProductions | PatternProductions,
     AllProductions = (StandardProductions | FormalParametersProductions |
                       ArrowFormalParametersProduction)
   };
 
-  enum FunctionProperties { NonSimpleParameter = 1 << 0 };
+  enum FunctionProperties {
+    NonSimpleParameter = 1 << 0,
+    ContainsExpressions = 1 << 1,
+    ArgumentsParameter = 1 << 2
+  };
 
   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) {}
@@ skipping 67 matching lines @@
   }
 
   bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
   }
 
   void RecordNonSimpleParameter() {
     function_properties_ |= NonSimpleParameter;
   }
 
+  bool contains_expressions() const {
+    return (function_properties_ & ContainsExpressions);
+  }
+
+  void RecordContainsExpressions() {
+    function_properties_ |= ContainsExpressions;
+  }
+
+  bool has_arguments_parameter() const {
+    return (function_properties_ & ArgumentsParameter);
+  }
+
+  void RecordArgumentsParameter() {
+    function_properties_ |= ArgumentsParameter;
+  }
+
   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;
   }
 
@@ skipping 127 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