Fix invalid use of int in Zone.

src/compiler/scheduler.cc

 // Copyright 2013 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/compiler/scheduler.h"
 
 #include "src/bit-vector.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-equivalence.h"
 #include "src/compiler/graph.h"
@@ skipping 347 matching lines @@
       block = schedule_->NewBasicBlock();
       Trace("Create block B%d for #%d:%s\n", block->id().ToInt(), node->id(),
             node->op()->mnemonic());
       FixNode(block, node);
     }
     return block;
   }
 
   void BuildBlocksForSuccessors(Node* node) {
     size_t const successor_count = node->op()->ControlOutputCount();
-    Node** successors =
-        zone_->NewArray<Node*>(static_cast<int>(successor_count));
+    Node** successors = zone_->NewArray<Node*>(successor_count);
     CollectSuccessorProjections(node, successors, successor_count);
     for (size_t index = 0; index < successor_count; ++index) {
       BuildBlockForNode(successors[index]);
     }
   }
 
   // Collect the branch-related projections from a node, such as IfTrue,
   // IfFalse, and Case.
   void CollectSuccessorProjections(Node* node, Node** successors,
                                    size_t successor_count) {
@@ skipping 70 matching lines @@
       TraceConnect(branch, branch_block, successor_blocks[0]);
       TraceConnect(branch, branch_block, successor_blocks[1]);
       schedule_->AddBranch(branch_block, branch, successor_blocks[0],
                            successor_blocks[1]);
     }
   }
 
   void ConnectSwitch(Node* sw) {
     size_t const successor_count = sw->op()->ControlOutputCount();
     BasicBlock** successor_blocks =
-        zone_->NewArray<BasicBlock*>(static_cast<int>(successor_count));
+        zone_->NewArray<BasicBlock*>(successor_count);
     CollectSuccessorBlocks(sw, successor_blocks, successor_count);
 
     if (sw == component_entry_) {
       for (size_t index = 0; index < successor_count; ++index) {
         TraceConnect(sw, component_start_, successor_blocks[index]);
       }
       schedule_->InsertSwitch(component_start_, component_end_, sw,
                               successor_blocks, successor_count);
     } else {
       Node* sw_block_node = NodeProperties::GetControlInput(sw);
@@ skipping 1178 matching lines @@
   for (Node* const node : *nodes) {
     schedule_->SetBlockForNode(to, node);
     scheduled_nodes_[to->id().ToSize()].push_back(node);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8