[mlir] Add `Block::eraseArguments` that erases a subrange

[Mogball]

Summary

This patch adds a an eraseArguments function that erases a subrange of
a block's arguments. This can be used inplace of the terrible pattern

block->eraseArguments(llvm::to_vector(llvm::seq(...)));

[rriddle]

mlir/include/mlir/IR/Block.h

110–113

Is this one used anywhere? Kind of sad that we are growing so many different ways to erase arguments. I wonder if it'd be better to just have an erase method on BlockArgument and drop some of these overloads. Maybe also having a custom BlockArgumentList that has some utility erase methods as well (for batch erasing ranges).

[Mogball]

mlir/include/mlir/IR/Block.h

110–113

This one has exactly one use that could probably be removed in favour of the BitVector one.

mlir/include/mlir/IR/Block.h

public:
   iterator_range<args_iterator> addArguments(TypeRange types,
                                              ArrayRef<Location> locs);
 
   /// 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/Conversion/TosaToSCF/TosaToSCF.cpp

static void inlineIfCase(Region &srcRegion, Region &dstRegion,
   for (auto it : llvm::zip(headBlock->getArguments(), operands))
     std::get<0>(it).replaceAllUsesWith(std::get<1>(it));
 
   auto yield = cast<YieldOp>(headBlock->getTerminator());
   rewriter.setInsertionPoint(yield);
   rewriter.create<scf::YieldOp>(yield.getLoc(), yield.getInputs());
   rewriter.eraseOp(yield);
 
-  headBlock->eraseArguments(
-      llvm::to_vector<4>(llvm::seq<unsigned>(0, headBlock->getNumArguments())));
+  headBlock->eraseArguments(0, headBlock->getNumArguments());
 }
 
 static void inlineWhileCase(Region &srcRegion, Region &dstRegion,
                             PatternRewriter &rewriter, bool isCond) {
   rewriter.cloneRegionBefore(srcRegion, &dstRegion.back());
   rewriter.eraseBlock(&dstRegion.back());
 
   Block *headBlock = &dstRegion.front();

mlir/lib/Dialect/Affine/Utils/Utils.cpp

mlir::affineParallelize(AffineForOp forOp,
   }
 
   // Update the loop terminator to yield reduced values bypassing the reduction
   // operation itself (now moved outside of the loop) and erase the block
   // arguments that correspond to reductions. Note that the loop always has one
   // "main" induction variable whenc coming from a non-parallel for.
   unsigned numIVs = 1;
   yieldOp->setOperands(reducedValues);
-  newPloop.getBody()->eraseArguments(
-      llvm::to_vector<4>(llvm::seq<unsigned>(numIVs, numReductions + numIVs)));
+  newPloop.getBody()->eraseArguments(numIVs, numReductions);
 
   forOp.erase();
   return success();
 }
 
 // Returns success if any hoisting happened.
 LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   // Bail out early if the ifOp returns a result.  TODO: Consider how to

mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp

if (noMinMaxBounds && needInboundCheck) {
     b.setInsertionPointToStart(innerLoop.getBody());
     for (const auto &ivs : llvm::enumerate(llvm::zip(
              innerLoop.getInductionVars(), outerLoop.getInductionVars()))) {
       auto newIndex = b.create<arith::AddIOp>(
           op.getLoc(), std::get<0>(ivs.value()), std::get<1>(ivs.value()));
       thenBlock.getArgument(ivs.index())
           .replaceAllUsesExcept(newIndex, newIndex);
     }
-    thenBlock.eraseArguments(llvm::to_vector<4>(
-        llvm::seq((unsigned)0, thenBlock.getNumArguments())));
+    thenBlock.eraseArguments(0, thenBlock.getNumArguments());
   } else {
     innerLoop.getRegion().takeBody(op.getRegion());
     b.setInsertionPointToStart(innerLoop.getBody());
     for (auto ivs : llvm::zip(innerLoop.getInductionVars(),
                               outerLoop.getInductionVars())) {
       Value innerIndex = std::get<0>(ivs);
       auto newIndex = b.create<arith::AddIOp>(op.getLoc(), std::get<0>(ivs),
                                               std::get<1>(ivs));

mlir/lib/IR/Block.cpp

 void Block::eraseArgument(unsigned index) {
   assert(index < arguments.size());
   arguments[index].destroy();
   arguments.erase(arguments.begin() + index);
   for (BlockArgument arg : llvm::drop_begin(arguments, index))
     arg.setArgNumber(index++);
 }
 
+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) {