[mlir] Remove a not very useful `eraseArguments` overload

[Mogball]

Summary

This overload just wraps a bitvector, and in most cases a bitvector
could be used directly instead of a list.

[rriddle]

Sweet!

mlir/include/mlir/IR/Block.h

public:
 
   /// Add one value to the argument list at the specified position.
   BlockArgument insertArgument(unsigned index, Type type, Location loc);
 
   /// Erase the argument at 'index' and remove it from the argument list.
   void eraseArgument(unsigned index);
   /// Erases 'num' arguments from the index 'start'.
   void eraseArguments(unsigned start, unsigned num);
-  /// Erases the arguments listed in `argIndices` and removes them from the
-  /// argument list.
-  /// `argIndices` is allowed to have duplicates and can be in any order.
-  void eraseArguments(ArrayRef<unsigned> argIndices);
   /// Erases the arguments that have their corresponding bit set in
   /// `eraseIndices` and removes them from the argument list.
   void eraseArguments(const BitVector &eraseIndices);
   /// Erases arguments using the given predicate. If the predicate returns true,
   /// that argument is erased.
   void eraseArguments(function_ref<bool(BlockArgument)> shouldEraseFn);
 
   unsigned getNumArguments() { return arguments.size(); }

mlir/lib/Dialect/SCF/IR/SCF.cpp

if (!llvm::any_of(op.getBeforeArguments(),
                       [](Value arg) { return arg.use_empty(); }))
       return failure();
 
     YieldOp yield = op.getYieldOp();
 
     // Collect results mapping, new terminator args and new result types.
     SmallVector<Value> newYields;
     SmallVector<Value> newInits;
-    SmallVector<unsigned> argsToErase;
+    llvm::BitVector argsToErase(op.getBeforeArguments().size());
     for (const auto &it : llvm::enumerate(llvm::zip(
              op.getBeforeArguments(), yield.getOperands(), op.getInits()))) {
       Value beforeArg = std::get<0>(it.value());
       Value yieldValue = std::get<1>(it.value());
       Value initValue = std::get<2>(it.value());
       if (beforeArg.use_empty()) {
-        argsToErase.push_back(it.index());
+        argsToErase.set(it.index());
       } else {
         newYields.emplace_back(yieldValue);
         newInits.emplace_back(initValue);
       }
     }
 
-    if (argsToErase.empty())
+    if (argsToErase.none())
       return failure();
 
     rewriter.startRootUpdate(op);
     op.getBefore().front().eraseArguments(argsToErase);
     rewriter.finalizeRootUpdate(op);
 
     WhileOp replacement =
         rewriter.create<WhileOp>(op.getLoc(), op.getResultTypes(), newInits);

mlir/lib/IR/Block.cpp

void Block::eraseArguments(unsigned start, unsigned num) {
   assert(start + num <= arguments.size());
   for (unsigned i = 0; i < num; ++i)
     arguments[start + i].destroy();
   arguments.erase(arguments.begin() + start, arguments.begin() + start + num);
   for (BlockArgument arg : llvm::drop_begin(arguments, start))
     arg.setArgNumber(start++);
 }
 
-void Block::eraseArguments(ArrayRef<unsigned> argIndices) {
-  BitVector eraseIndices(getNumArguments());
-  for (unsigned i : argIndices)
-    eraseIndices.set(i);
-  eraseArguments(eraseIndices);
-}
-
 void Block::eraseArguments(const BitVector &eraseIndices) {
   eraseArguments(
       [&](BlockArgument arg) { return eraseIndices.test(arg.getArgNumber()); });
 }
 
 void Block::eraseArguments(function_ref<bool(BlockArgument)> shouldEraseFn) {
   auto firstDead = llvm::find_if(arguments, shouldEraseFn);
   if (firstDead == arguments.end())