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"
 
 namespace v8 {
 namespace internal {
 
 class Processor final : public AstVisitor<Processor> {
  public:
-  Processor(Isolate* isolate, Scope* scope, Variable* result,
+  Processor(Isolate* isolate, Scope* closure_scope, Variable* result,
             AstValueFactory* ast_value_factory)
       : result_(result),
         result_assigned_(false),
         replacement_(nullptr),
         is_set_(false),
         zone_(ast_value_factory->zone()),
-        scope_(scope),
+        closure_scope_(closure_scope),
         factory_(ast_value_factory) {
+    DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
     InitializeAstVisitor(isolate);
   }
 
-  Processor(Parser* parser, Scope* scope, Variable* result,
+  Processor(Parser* parser, Scope* closure_scope, Variable* result,
             AstValueFactory* ast_value_factory)
       : result_(result),
         result_assigned_(false),
         replacement_(nullptr),
         is_set_(false),
         zone_(ast_value_factory->zone()),
-        scope_(scope),
+        closure_scope_(closure_scope),
         factory_(ast_value_factory) {
+    DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
     InitializeAstVisitor(parser->stack_limit());
   }
 
   void Process(ZoneList<Statement*>* statements);
   bool result_assigned() const { return result_assigned_; }
 
   Zone* zone() { return zone_; }
-  Scope* scope() { return scope_; }
+  Scope* closure_scope() { return closure_scope_; }
   AstNodeFactory* factory() { return &factory_; }
 
   // Returns ".result = value"
   Expression* SetResult(Expression* value) {
     result_assigned_ = true;
     VariableProxy* result_proxy = factory()->NewVariableProxy(result_);
     return factory()->NewAssignment(Token::ASSIGN, result_proxy, value,
                                     kNoSourcePosition);
   }
 
@@ skipping 13 matching lines @@
   // [replacement_].  In many cases this will just be the original node.
   Statement* replacement_;
 
   // To avoid storing to .result all the time, we eliminate some of
   // the stores by keeping track of whether or not we're sure .result
   // will be overwritten anyway. This is a bit more tricky than what I
   // was hoping for.
   bool is_set_;
 
   Zone* zone_;
-  Scope* scope_;
+  Scope* closure_scope_;
   AstNodeFactory factory_;
 
   // Node visitors.
 #define DEF_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   void VisitIterationStatement(IterationStatement* stmt);
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
@@ skipping 127 matching lines @@
 void Processor::VisitTryFinallyStatement(TryFinallyStatement* node) {
   // Rewrite both try and finally block (in reverse order).
   bool set_after = is_set_;
   is_set_ = true;  // Don't normally need to assign in finally block.
   Visit(node->finally_block());
   node->set_finally_block(replacement_->AsBlock());
   {  // Save .result value at the beginning of the finally block and restore it
      // at the end again: ".backup = .result; ...; .result = .backup"
      // This is necessary because the finally block does not normally contribute
      // to the completion value.
-    CHECK(scope() != nullptr);
-    Variable* backup = scope()->NewTemporary(
-        factory()->ast_value_factory()->dot_result_string());
-    Expression* backup_proxy = factory()->NewVariableProxy(backup);
-    Expression* result_proxy = factory()->NewVariableProxy(result_);
-    Expression* save = factory()->NewAssignment(
-        Token::ASSIGN, backup_proxy, result_proxy, kNoSourcePosition);
-    Expression* restore = factory()->NewAssignment(
-        Token::ASSIGN, result_proxy, backup_proxy, kNoSourcePosition);
-    node->finally_block()->statements()->InsertAt(
-        0, factory()->NewExpressionStatement(save, kNoSourcePosition), zone());
-    node->finally_block()->statements()->Add(
-        factory()->NewExpressionStatement(restore, kNoSourcePosition), zone());
+     CHECK_NOT_NULL(closure_scope());
+     Variable* backup = closure_scope()->NewTemporary(
+         factory()->ast_value_factory()->dot_result_string());
+     Expression* backup_proxy = factory()->NewVariableProxy(backup);
+     Expression* result_proxy = factory()->NewVariableProxy(result_);
+     Expression* save = factory()->NewAssignment(
+         Token::ASSIGN, backup_proxy, result_proxy, kNoSourcePosition);
+     Expression* restore = factory()->NewAssignment(
+         Token::ASSIGN, result_proxy, backup_proxy, kNoSourcePosition);
+     node->finally_block()->statements()->InsertAt(
+         0, factory()->NewExpressionStatement(save, kNoSourcePosition), zone());
+     node->finally_block()->statements()->Add(
+         factory()->NewExpressionStatement(restore, kNoSourcePosition), zone());
   }
   is_set_ = set_after;
   Visit(node->try_block());
   node->set_try_block(replacement_->AsBlock());
   replacement_ = node;
 
   if (!is_set_) {
     is_set_ = true;
     replacement_ = AssignUndefinedBefore(node);
   }
@@ skipping 77 matching lines @@
 #define DEF_VISIT(type) \
   void Processor::Visit##type(type* expr) { UNREACHABLE(); }
 DECLARATION_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
 
 // Assumes code has been parsed.  Mutates the AST, so the AST should not
 // continue to be used in the case of failure.
 bool Rewriter::Rewrite(ParseInfo* info) {
   FunctionLiteral* function = info->literal();
-  DCHECK(function != NULL);
+  DCHECK_NOT_NULL(function);
   Scope* scope = function->scope();
-  DCHECK(scope != NULL);
+  DCHECK_NOT_NULL(scope);
   if (!scope->is_script_scope() && !scope->is_eval_scope()) return true;
+  Scope* closure_scope = scope->ClosureScope();
 
   ZoneList<Statement*>* body = function->body();
   if (!body->is_empty()) {
-    Variable* result =
-        scope->NewTemporary(info->ast_value_factory()->dot_result_string());
+    Variable* result = closure_scope->NewTemporary(
+        info->ast_value_factory()->dot_result_string());
     // The name string must be internalized at this point.
     DCHECK(!result->name().is_null());
-    Processor processor(info->isolate(), scope, result,
+    Processor processor(info->isolate(), closure_scope, result,
                         info->ast_value_factory());
     processor.Process(body);
     if (processor.HasStackOverflow()) return false;
 
     if (processor.result_assigned()) {
       int pos = kNoSourcePosition;
       VariableProxy* result_proxy =
           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* closure_scope, DoExpression* expr,
                        AstValueFactory* factory) {
   Block* block = expr->block();
-  Scope* scope = block->scope();
+  DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
+  DCHECK(block->scope() == nullptr ||
+         block->scope()->ClosureScope() == closure_scope);
   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 processor(parser, closure_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