Fix completion of try..finally.

src/pattern-rewriter.cc

 // Copyright 2015 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/ast.h"
 #include "src/messages.h"
 #include "src/parser.h"
 
 namespace v8 {
 
@@ skipping 153 matching lines @@
         // and add it to the initialization statement block.
         initialize =
             factory()->NewCallRuntime(Runtime::kInitializeVarGlobal, arguments,
                                       descriptor_->declaration_pos);
       } else {
         initialize = NULL;
       }
     }
 
     if (initialize != NULL) {
-      block_->AddStatement(
+      block_->statements()->Add(
           factory()->NewExpressionStatement(initialize, RelocInfo::kNoPosition),
           zone());
     }
   } else if (value != nullptr && (descriptor_->needs_init ||
                                   IsLexicalVariableMode(descriptor_->mode))) {
     // Constant initializations always assign to the declared constant which
     // is always at the function scope level. This is only relevant for
     // dynamically looked-up variables and constants (the
     // start context for constant lookups is always the function context,
     // while it is the top context for var declared variables). Sigh...
     // For 'let' and 'const' declared variables in harmony mode the
     // initialization also always assigns to the declared variable.
     DCHECK_NOT_NULL(proxy);
     DCHECK_NOT_NULL(proxy->var());
     DCHECK_NOT_NULL(value);
     Assignment* assignment = factory()->NewAssignment(
         descriptor_->init_op, proxy, value, descriptor_->initialization_pos);
-    block_->AddStatement(
+    block_->statements()->Add(
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
         zone());
     value = NULL;
   }
 
   // Add an assignment node to the initialization statement block if we still
   // have a pending initialization value.
   if (value != NULL) {
     DCHECK(descriptor_->mode == VAR);
     // 'var' initializations are simply assignments (with all the consequences
     // if they are inside a 'with' statement - they may change a 'with' object
     // property).
     VariableProxy* proxy = initialization_scope->NewUnresolved(factory(), name);
     Assignment* assignment = factory()->NewAssignment(
         descriptor_->init_op, proxy, value, descriptor_->initialization_pos);
-    block_->AddStatement(
+    block_->statements()->Add(
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
         zone());
   }
 }
 
 
 Variable* Parser::PatternRewriter::CreateTempVar(Expression* value) {
   auto temp = descriptor_->parser->scope_->NewTemporary(
       ast_value_factory()->empty_string());
   if (value != nullptr) {
     auto assignment = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp), value,
         RelocInfo::kNoPosition);
 
-    block_->AddStatement(
+    block_->statements()->Add(
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
         zone());
   }
   return temp;
 }
 
 
 void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* pattern) {
   auto temp = CreateTempVar(current_value_);
 
-  block_->AddStatement(descriptor_->parser->BuildAssertIsCoercible(temp),
-                       zone());
+  block_->statements()->Add(descriptor_->parser->BuildAssertIsCoercible(temp),
+                            zone());
 
   for (ObjectLiteralProperty* property : *pattern->properties()) {
     RecurseIntoSubpattern(
         property->value(),
         factory()->NewProperty(factory()->NewVariableProxy(temp),
                                property->key(), RelocInfo::kNoPosition));
   }
 }
 
 
@@ skipping 11 matching lines @@
       spread = value->AsSpread();
       break;
     }
 
     // if (!done) {
     //   result = IteratorNext(iterator);
     //   v = (done = result.done) ? undefined : result.value;
     // }
     auto next_block =
         factory()->NewBlock(nullptr, 2, true, RelocInfo::kNoPosition);
-    next_block->AddStatement(factory()->NewExpressionStatement(
-                                 descriptor_->parser->BuildIteratorNextResult(
-                                     factory()->NewVariableProxy(iterator),
-                                     result, RelocInfo::kNoPosition),
-                                 RelocInfo::kNoPosition),
-                             zone());
+    next_block->statements()->Add(
+        factory()->NewExpressionStatement(
+            descriptor_->parser->BuildIteratorNextResult(
+                factory()->NewVariableProxy(iterator), result,
+                RelocInfo::kNoPosition),
+            RelocInfo::kNoPosition),
+        zone());
 
     auto assign_to_done = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(done),
         factory()->NewProperty(
             factory()->NewVariableProxy(result),
             factory()->NewStringLiteral(ast_value_factory()->done_string(),
                                         RelocInfo::kNoPosition),
             RelocInfo::kNoPosition),
         RelocInfo::kNoPosition);
     auto next_value = factory()->NewConditional(
         assign_to_done, factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
         factory()->NewProperty(
             factory()->NewVariableProxy(result),
             factory()->NewStringLiteral(ast_value_factory()->value_string(),
                                         RelocInfo::kNoPosition),
             RelocInfo::kNoPosition),
         RelocInfo::kNoPosition);
-    next_block->AddStatement(
+    next_block->statements()->Add(
         factory()->NewExpressionStatement(
             factory()->NewAssignment(Token::ASSIGN,
                                      factory()->NewVariableProxy(v), next_value,
                                      RelocInfo::kNoPosition),
             RelocInfo::kNoPosition),
         zone());
 
     auto if_statement = factory()->NewIfStatement(
         factory()->NewUnaryOperation(Token::NOT,
                                      factory()->NewVariableProxy(done),
                                      RelocInfo::kNoPosition),
         next_block, factory()->NewEmptyStatement(RelocInfo::kNoPosition),
         RelocInfo::kNoPosition);
-    block_->AddStatement(if_statement, zone());
+    block_->statements()->Add(if_statement, zone());
 
     if (!(value->IsLiteral() && value->AsLiteral()->raw_value()->IsTheHole())) {
       RecurseIntoSubpattern(value, factory()->NewVariableProxy(v));
     }
   }
 
   if (spread != nullptr) {
     // array = [];
     // if (!done) %concat_iterable_to_array(array, iterator);
     auto empty_exprs = new (zone()) ZoneList<Expression*>(0, zone());
@@ skipping 12 matching lines @@
                                   arguments, RelocInfo::kNoPosition);
 
     auto if_statement = factory()->NewIfStatement(
         factory()->NewUnaryOperation(Token::NOT,
                                      factory()->NewVariableProxy(done),
                                      RelocInfo::kNoPosition),
         factory()->NewExpressionStatement(spread_into_array_call,
                                           RelocInfo::kNoPosition),
         factory()->NewEmptyStatement(RelocInfo::kNoPosition),
         RelocInfo::kNoPosition);
-    block_->AddStatement(if_statement, zone());
-
+    block_->statements()->Add(if_statement, zone());
 
     RecurseIntoSubpattern(spread->expression(),
                           factory()->NewVariableProxy(array));
   }
 }
 
 
 void Parser::PatternRewriter::VisitAssignment(Assignment* node) {
   // let {<pattern> = <init>} = <value>
   //   becomes
@@ skipping 62 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8