[es6] Self-assignment in a default parameter initializer should throw

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 4070 matching lines @@
     DCHECK(parser_->allow_harmony_default_parameters());
     DCHECK(!assignment->is_compound());
     initializer = assignment->value();
     expr = assignment->target();
 
     // TODO(adamk): Only call this if necessary.
     RewriteParameterInitializerScope(parser_->stack_limit(), initializer,
                                      parser_->scope_, parameters->scope);
   }
 
-  AddFormalParameter(parameters, expr, initializer, is_rest);
+  // TODO(adamk): params_loc.end_pos is not the correct initializer position,
+  // but it should be conservative enough to trigger hole checks for variables
+  // referenced in the initializer (if any).
+  AddFormalParameter(parameters, expr, initializer, params_loc.end_pos,
+                     is_rest);
 }
 
 
 DoExpression* Parser::ParseDoExpression(bool* ok) {
   // AssignmentExpression ::
   //     do '{' StatementList '}'
   int pos = peek_position();
 
   Expect(Token::DO, CHECK_OK);
   Variable* result =
@@ skipping 441 matching lines @@
     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.is_const = false;
     descriptor.needs_init = true;
     descriptor.declaration_pos = parameter.pattern->position();
+    // The position that will be used by the AssignmentExpression
+    // which copies from the temp parameter to the pattern.
+    //
+    // TODO(adamk): Should this be RelocInfo::kNoPosition, since
+    // it's just copying from a temp var to the real param var?
     descriptor.initialization_pos = parameter.pattern->position();
+    // The initializer position which will end up in,
+    // Variable::initializer_position(), used for hole check elimination.
+    int initializer_position = parameter.pattern->position();
     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();
+      initializer_position = parameter.initializer_end_position;
     } else if (parameter.is_rest) {
       // $rest = [];
       // for (var $argument_index = $rest_index;
       //      $argument_index < %_ArgumentsLength();
       //      ++$argument_index) {
       //   %AppendElement($rest, %_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);
       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, factory()->NewVariableProxy(temp_var), empty_array,
           RelocInfo::kNoPosition);
 
@@ skipping 43 matching lines @@
                                     RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
 
       loop->Initialize(init, cond, next, body);
 
       init_block->statements()->Add(
           factory()->NewExpressionStatement(init_array, RelocInfo::kNoPosition),
           zone());
 
       init_block->statements()->Add(loop, zone());
-
-      descriptor.initialization_pos = pos;
     }
 
     Scope* param_scope = scope_;
     Block* param_block = init_block;
     if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
       param_scope = NewScope(scope_, BLOCK_SCOPE);
       param_scope->set_is_declaration_scope();
       param_scope->set_start_position(parameter.pattern->position());
       param_scope->set_end_position(RelocInfo::kNoPosition);
       param_scope->RecordEvalCall();
       param_block = factory()->NewBlock(NULL, 8, true, RelocInfo::kNoPosition);
       param_block->set_scope(param_scope);
       descriptor.hoist_scope = scope_;
     }
 
     {
       BlockState block_state(&scope_, param_scope);
       DeclarationParsingResult::Declaration decl(
-          parameter.pattern, parameter.pattern->position(), initial_value);
+          parameter.pattern, initializer_position, initial_value);
       PatternRewriter::DeclareAndInitializeVariables(param_block, &descriptor,
                                                      &decl, nullptr, CHECK_OK);
     }
 
     if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
       param_scope = param_scope->FinalizeBlockScope();
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);
       }
       init_block->statements()->Add(param_block, zone());
@@ skipping 1782 matching lines @@
 }
 
 
 void Parser::RaiseLanguageMode(LanguageMode mode) {
   SetLanguageMode(scope_,
                   static_cast<LanguageMode>(scope_->language_mode() | mode));
 }
 
 }  // namespace internal
 }  // namespace v8