[es6] conditionally ignore TDZ semantics for formals

src/parser.cc

 // Copyright 2012 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.
 
 #include "src/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 2024 matching lines @@
   // declarations to the caller's scope so we declare all locals, too.
   if (declaration_scope->is_function_scope() ||
       declaration_scope->is_block_scope() ||
       declaration_scope->is_module_scope() ||
       declaration_scope->is_script_scope() ||
       (declaration_scope->is_eval_scope() &&
        (is_strict(declaration_scope->language_mode()) ||
         IsLexicalVariableMode(mode)))) {
     // Declare the variable in the declaration scope.
     var = declaration_scope->LookupLocal(name);
+    bool redeclared_parameter =
+        var != nullptr &&
+        declaration_kind == DeclarationDescriptor::PARAMETER &&
+        (is_strict(language_mode()) ||
+         !declaration_scope->has_simple_parameters());
+    if (redeclared_parameter && var->is_arguments()) {
+      var = nullptr;
+      redeclared_parameter = false;
+    }
+
     if (var == NULL) {
       // Declare the name.
       Variable::Kind kind = Variable::NORMAL;
       int declaration_group_start = -1;
       if (declaration->IsFunctionDeclaration()) {
         kind = Variable::FUNCTION;
       } else if (declaration->IsVariableDeclaration() &&
                  declaration->AsVariableDeclaration()->is_class_declaration()) {
         kind = Variable::CLASS;
         declaration_group_start =
             declaration->AsVariableDeclaration()->declaration_group_start();
       }
       var = declaration_scope->DeclareLocal(
           name, mode, declaration->initialization(), kind, kNotAssigned,
           declaration_group_start);
     } else if (IsLexicalVariableMode(mode) ||
                IsLexicalVariableMode(var->mode()) ||
                ((mode == CONST_LEGACY || var->mode() == CONST_LEGACY) &&
-                !declaration_scope->is_script_scope())) {
+                !declaration_scope->is_script_scope()) ||
+               redeclared_parameter) {
       // The name was declared in this scope before; check for conflicting
       // re-declarations. We have a conflict if either of the declarations is
       // not a var (in script scope, we also have to ignore legacy const for
       // compatibility). There is similar code in runtime.cc in the Declare
       // functions. The function CheckConflictingVarDeclarations checks for
       // var and let bindings from different scopes whereas this is a check for
       // conflicting declarations within the same scope. This check also covers
       // the special case
       //
       // function () { let x; { var x; } }
       //
       // because the var declaration is hoisted to the function scope where 'x'
       // is already bound.
       DCHECK(IsDeclaredVariableMode(var->mode()));
-      if (is_strict(language_mode()) || allow_harmony_sloppy()) {
+      if (is_strict(language_mode()) || allow_harmony_sloppy() ||
+          redeclared_parameter) {
         // In harmony we treat re-declarations as early errors. See
         // ES5 16 for a definition of early errors.
         if (declaration_kind == DeclarationDescriptor::NORMAL) {
           ParserTraits::ReportMessage(MessageTemplate::kVarRedeclaration, name);
         } else {
           ParserTraits::ReportMessage(MessageTemplate::kParamDupe);
         }
         *ok = false;
         return nullptr;
       }
@@ skipping 2292 matching lines @@
       factory()->NewEmptyStatement(RelocInfo::kNoPosition),
       RelocInfo::kNoPosition);
   return if_statement;
 }
 
 
 Block* Parser::BuildParameterInitializationBlock(
     const ParserFormalParameters& parameters, bool* ok) {
   DCHECK(!parameters.is_simple);
   DCHECK(scope_->is_function_scope());
+  VariableMode parameter_mode = VAR;
+  Token::Value init_op = Token::INIT_VAR;
+
+  if (parameters.contains_expressions) {
+    parameter_mode = LET;
+    init_op = Token::INIT_LET;
+  }
+
   Block* init_block =
       factory()->NewBlock(NULL, 1, true, RelocInfo::kNoPosition);
   for (int i = 0; i < parameters.params.length(); ++i) {
     auto parameter = parameters.params[i];
     DeclarationDescriptor descriptor;
     descriptor.declaration_kind = DeclarationDescriptor::PARAMETER;
     descriptor.parser = this;
     descriptor.declaration_scope = scope_;
     descriptor.scope = scope_;
     descriptor.hoist_scope = nullptr;
-    descriptor.mode = LET;
+    descriptor.mode = parameter_mode;
     descriptor.is_const = false;
     descriptor.needs_init = true;
     descriptor.declaration_pos = parameter.pattern->position();
     descriptor.initialization_pos = parameter.pattern->position();
-    descriptor.init_op = Token::INIT_LET;
+    descriptor.init_op = init_op;
     Expression* initial_value =
         factory()->NewVariableProxy(parameters.scope->parameter(i));
     if (parameter.initializer != nullptr) {
       // IS_UNDEFINED($param) ? initializer : $param
       DCHECK(!parameter.is_rest);
       auto condition = factory()->NewCompareOperation(
           Token::EQ_STRICT,
           factory()->NewVariableProxy(parameters.scope->parameter(i)),
           factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
       initial_value = factory()->NewConditional(
           condition, parameter.initializer, initial_value,
           RelocInfo::kNoPosition);
       descriptor.initialization_pos = parameter.initializer->position();
     } else if (parameter.is_rest) {
+      // var $arguments_length = %_ArgumentsLength()
       // $rest = [];
       // for (var $argument_index = $rest_index;
       //      $argument_index < %_ArgumentsLength();
       //      ++$argument_index) {
-      //   %AppendElement($rest, %_Arguments($argument_index));
+      //   /* TODO: use CreateDataProperty($rest, $argument_index - $rest_index,
+      //                                   %_Arguments($argument_index)) */
+      //   $rest[$argument_index - $rest_index] = $_Arguments($argument_index)
       // }
       // let <param> = $rest;
       DCHECK(parameter.pattern->IsVariableProxy());
       DCHECK_EQ(i, parameters.params.length() - 1);
 
       int pos = parameter.pattern->position();
       Variable* temp_var = parameters.scope->parameter(i);
+      Variable* arguments_length =
+          parameters.scope->NewTemporary(ast_value_factory()->empty_string());
+
+      // var $arguments_length = %_ArgumentsLength();
+      auto empty_arguments = new (zone()) ZoneList<Expression*>(0, zone());
+      auto init_arguments_length = factory()->NewAssignment(
+          Token::INIT_VAR, factory()->NewVariableProxy(arguments_length),
+          factory()->NewCallRuntime(Runtime::kInlineArgumentsLength,
+                                    empty_arguments, RelocInfo::kNoPosition),
+          RelocInfo::kNoPosition);
+
+      // $rest = Array($arguments_length && $arguments_length - 1);
       auto empty_values = new (zone()) ZoneList<Expression*>(0, zone());
       auto empty_array = factory()->NewArrayLiteral(
           empty_values, parameters.rest_array_literal_index,
           is_strong(language_mode()), RelocInfo::kNoPosition);
 
       auto init_array = factory()->NewAssignment(
           Token::INIT_VAR, factory()->NewVariableProxy(temp_var), empty_array,
           RelocInfo::kNoPosition);
 
+
       auto loop = factory()->NewForStatement(NULL, RelocInfo::kNoPosition);
 
-      auto argument_index =
+      Variable* argument_index =
           parameters.scope->NewTemporary(ast_value_factory()->empty_string());
       auto init = factory()->NewExpressionStatement(
           factory()->NewAssignment(
               Token::INIT_VAR, factory()->NewVariableProxy(argument_index),
               factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
               RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
 
-      auto empty_arguments = new (zone()) ZoneList<Expression*>(0, zone());
-
       // $arguments_index < arguments.length
       auto cond = factory()->NewCompareOperation(
           Token::LT, factory()->NewVariableProxy(argument_index),
-          factory()->NewCallRuntime(Runtime::kInlineArgumentsLength,
-                                    empty_arguments, RelocInfo::kNoPosition),
+          factory()->NewVariableProxy(arguments_length),
           RelocInfo::kNoPosition);
 
       // ++argument_index
       auto next = factory()->NewExpressionStatement(
           factory()->NewCountOperation(
               Token::INC, true, factory()->NewVariableProxy(argument_index),
               RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
 
       // %_Arguments($arguments_index)
       auto arguments_args = new (zone()) ZoneList<Expression*>(1, zone());
       arguments_args->Add(factory()->NewVariableProxy(argument_index), zone());
 
-      // %AppendElement($rest, %_Arguments($arguments_index))
-      auto append_element_args = new (zone()) ZoneList<Expression*>(2, zone());
-
-      append_element_args->Add(factory()->NewVariableProxy(temp_var), zone());
-      append_element_args->Add(
-          factory()->NewCallRuntime(Runtime::kInlineArguments, arguments_args,
-                                    RelocInfo::kNoPosition),
-          zone());
-
+      // $rest[ $arguments_index - $rest_index ] = %_Arguments($arguments_index)
       auto body = factory()->NewExpressionStatement(
-          factory()->NewCallRuntime(Runtime::kAppendElement,
-                                    append_element_args,
-                                    RelocInfo::kNoPosition),
+          factory()->NewAssignment(
+              Token::ASSIGN,
+              factory()->NewProperty(
+                  factory()->NewVariableProxy(temp_var),
+                  factory()->NewBinaryOperation(
+                      Token::SUB, factory()->NewVariableProxy(argument_index),
+                      factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
+                      RelocInfo::kNoPosition),
+                  RelocInfo::kNoPosition),
+              factory()->NewCallRuntime(Runtime::kInlineArguments,
+                                        arguments_args, RelocInfo::kNoPosition),
+              RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
 
       loop->Initialize(init, cond, next, body);
 
       init_block->AddStatement(
+          factory()->NewExpressionStatement(init_arguments_length,
+                                            RelocInfo::kNoPosition),
+          zone());
+      init_block->AddStatement(
           factory()->NewExpressionStatement(init_array, RelocInfo::kNoPosition),
           zone());
 
       init_block->AddStatement(loop, zone());
 
       descriptor.initialization_pos = pos;
     }
 
     Scope* param_scope = scope_;
     Block* param_block = init_block;
@@ skipping 51 matching lines @@
 
   // For concise constructors, check that they are constructed,
   // not called.
   if (i::IsConstructor(kind)) {
     AddAssertIsConstruct(result, pos);
   }
 
   ZoneList<Statement*>* body = result;
   Scope* inner_scope = scope_;
   Block* inner_block = nullptr;
-  if (!parameters.is_simple) {
+  if (parameters.contains_expressions) {
     inner_scope = NewScope(scope_, BLOCK_SCOPE);
     inner_scope->set_is_declaration_scope();
     inner_scope->set_start_position(scanner()->location().beg_pos);
     inner_block = factory()->NewBlock(NULL, 8, true, RelocInfo::kNoPosition);
     inner_block->set_scope(inner_scope);
     body = inner_block->statements();
+  } else if (!parameters.is_simple) {
+    Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
+    DCHECK_NOT_NULL(init_block);
+    result->Add(init_block, zone());
   }
 
   {
     BlockState block_state(&scope_, inner_scope);
 
     // For generators, allocate and yield an iterator on function entry.
     if (IsGeneratorFunction(kind)) {
       ZoneList<Expression*>* arguments =
           new(zone()) ZoneList<Expression*>(0, zone());
       CallRuntime* allocation = factory()->NewCallRuntime(
@@ skipping 28 matching lines @@
           factory()->NewReturnStatement(
               this->ThisExpression(scope_, factory(), RelocInfo::kNoPosition),
               RelocInfo::kNoPosition),
               zone());
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
 
-  if (!parameters.is_simple) {
+  if (parameters.contains_expressions) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(body, inner_block->statements());
+
+    DCHECK_NE(scope_, inner_scope);
     scope_->SetLanguageMode(inner_scope->language_mode());
     Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
     DCHECK_NOT_NULL(init_block);
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     inner_scope = inner_scope->FinalizeBlockScope();
     if (inner_scope != nullptr) {
       CheckConflictingVarDeclarations(inner_scope, CHECK_OK);
     }
 
@@ skipping 58 matching lines @@
     SET_ALLOW(harmony_default_parameters);
     SET_ALLOW(harmony_spreadcalls);
     SET_ALLOW(harmony_destructuring);
     SET_ALLOW(harmony_spread_arrays);
     SET_ALLOW(harmony_new_target);
     SET_ALLOW(strong_mode);
 #undef SET_ALLOW
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
       language_mode(), function_state_->kind(), scope_->has_simple_parameters(),
-      logger, bookmark);
+      scope_->has_parameter_expressions(), logger, bookmark);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
 
 ClassLiteral* Parser::ParseClassLiteral(const AstRawString* name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
@@ skipping 1494 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
 }
 }  // namespace internal
 }  // namespace v8