[es6] Remaining cases of parameter scopes for sloppy eval

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 4347 matching lines @@
           factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
       initial_value = factory()->NewConditional(
           condition, parameter.initializer, initial_value,
           RelocInfo::kNoPosition);
       descriptor.initialization_pos = parameter.initializer->position();
     }
 
     Scope* param_scope = scope_;
     Block* param_block = init_block;
-    if (parameter.initializer != nullptr && scope_->calls_sloppy_eval()) {
+    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);
       PatternRewriter::DeclareAndInitializeVariables(param_block, &descriptor,
                                                      &decl, nullptr, CHECK_OK);
     }
 
-    if (parameter.initializer != nullptr && scope_->calls_sloppy_eval()) {
+    if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
       param_scope = param_scope->FinalizeBlockScope();
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);

[Dan Ehrenberg, 2015/08/25 20:18:12]

Not new in this patch, but I'm wondering why we check this when it's a new
declaration scope that's introduced. I don't see how you could come up with a
conflict now, but with do-expressions I could imagine it, and that var
declaration should just not be visible anywhere after the parameters are
evaluated.

[rossberg, 2015/08/25 21:58:40]

Indeed, I did this with do-expressions in mind. Seemed "more correct" now, and
one thing less to overlook later. :)

       }
       init_block->AddStatement(param_block, zone());
     }
   }
   return init_block;
 }
 
 
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos,
@@ skipping 1672 matching lines @@
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 }  // namespace internal
 }  // namespace v8