Always finalize blocks after parsing, also for do-expressions

src/parsing/rewriter.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/parsing/rewriter.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser.h"
 
@@ skipping 344 matching lines @@
           processor.factory()->NewVariableProxy(result, pos);
       Statement* result_statement =
           processor.factory()->NewReturnStatement(result_proxy, pos);
       body->Add(result_statement, info->zone());
     }
   }
 
   return true;
 }
 
-
-bool Rewriter::Rewrite(Parser* parser, DoExpression* expr,
+bool Rewriter::Rewrite(Parser* parser, Scope* outer_scope, DoExpression* expr,
                        AstValueFactory* factory) {
   Block* block = expr->block();
-  Scope* scope = block->scope();
+  Scope* scope = block->scope() == nullptr ? outer_scope : block->scope();

[adamk, 2016/07/21 17:15:41]

Why should we ever use the block scope here? By your logic shouldn't it not
matter?

Could you rename the parameter to "scope" and replace this line with a DCHECK:

DCHECK(block->scope() == nullptr || (block->scope()->ClosureScope() ==
scope->ClosureScope()));

   ZoneList<Statement*>* body = block->statements();
   VariableProxy* result = expr->result();
   Variable* result_var = result->var();
 
   if (!body->is_empty()) {
     Processor processor(parser, scope, result_var, factory);
     processor.Process(body);
     if (processor.HasStackOverflow()) return false;
 
     if (!processor.result_assigned()) {
       AstNodeFactory* node_factory = processor.factory();
       Expression* undef = node_factory->NewUndefinedLiteral(kNoSourcePosition);
       Statement* completion = node_factory->NewExpressionStatement(
           processor.SetResult(undef), expr->position());
       body->Add(completion, factory->zone());
     }
   }
   return true;
 }
 
 
 }  // namespace internal
 }  // namespace v8