Remove all harmony runtime flags which shipped in M51

src/parsing/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/ast.h"
 #include "src/messages.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
@@ skipping 407 matching lines @@
   auto v = CreateTempVar();
   auto completion = CreateTempVar();
   auto nopos = RelocInfo::kNoPosition;
 
   // For the purpose of iterator finalization, we temporarily set block_ to a
   // new block.  In the main body of this function, we write to block_ (both
   // explicitly and implicitly via recursion).  At the end of the function, we
   // wrap this new block in a try-finally statement, restore block_ to its
   // original value, and add the try-finally statement to block_.
   auto target = block_;
-  if (FLAG_harmony_iterator_close) {
-    block_ = factory()->NewBlock(nullptr, 8, true, nopos);
-  }
+  block_ = factory()->NewBlock(nullptr, 8, true, nopos);
 
   Spread* spread = nullptr;
   for (Expression* value : *node->values()) {
     if (value->IsSpread()) {
       spread = value->AsSpread();
       break;
     }
 
     PatternContext context = SetInitializerContextIfNeeded(value);
 
@@ skipping 67 matching lines @@
       if_not_done = factory()->NewIfStatement(
           factory()->NewUnaryOperation(Token::NOT,
                                        factory()->NewVariableProxy(done),
                                        RelocInfo::kNoPosition),
           next_block, factory()->NewEmptyStatement(RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
     }
     block_->statements()->Add(if_not_done, zone());
 
     if (!(value->IsLiteral() && value->AsLiteral()->raw_value()->IsTheHole())) {
-      if (FLAG_harmony_iterator_close) {
+      {
         // completion = kAbruptCompletion;
         Expression* proxy = factory()->NewVariableProxy(completion);
         Expression* assignment = factory()->NewAssignment(
             Token::ASSIGN, proxy,
             factory()->NewSmiLiteral(kAbruptCompletion, nopos), nopos);
         block_->statements()->Add(
             factory()->NewExpressionStatement(assignment, nopos), zone());
       }
 
       RecurseIntoSubpattern(value, factory()->NewVariableProxy(v));
 
-      if (FLAG_harmony_iterator_close) {
+      {
         // completion = kNormalCompletion;
         Expression* proxy = factory()->NewVariableProxy(completion);
         Expression* assignment = factory()->NewAssignment(
             Token::ASSIGN, proxy,
             factory()->NewSmiLiteral(kNormalCompletion, nopos), nopos);
         block_->statements()->Add(
             factory()->NewExpressionStatement(assignment, nopos), zone());
       }
     }
     set_context(context);
@@ skipping 92 matching lines @@
       body->statements()->Add(get_next, zone());
       body->statements()->Add(maybe_append_and_unset_done, zone());
       loop->Initialize(condition, body);
     }
 
     block_->statements()->Add(loop, zone());
     RecurseIntoSubpattern(spread->expression(),
                           factory()->NewVariableProxy(array));
   }
 
-  if (FLAG_harmony_iterator_close) {
-    Expression* closing_condition = factory()->NewUnaryOperation(
-        Token::NOT, factory()->NewVariableProxy(done), nopos);
-    parser_->FinalizeIteratorUse(completion, closing_condition, iterator,
-                                 block_, target);
-    block_ = target;
-  }
+  Expression* closing_condition = factory()->NewUnaryOperation(
+      Token::NOT, factory()->NewVariableProxy(done), nopos);
+  parser_->FinalizeIteratorUse(completion, closing_condition, iterator, block_,
+                               target);
+  block_ = target;
 }
 
 
 void Parser::PatternRewriter::VisitArrayLiteral(ArrayLiteral* node) {
   Variable* temp_var = nullptr;
   VisitArrayLiteral(node, &temp_var);
 }
 
 
 void Parser::PatternRewriter::VisitAssignment(Assignment* node) {
@@ skipping 115 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