[mlir] Allow constructing a ValueRange from an ArrayRef<BlockArgument>

[rriddle]

Summary

This was a missed case when ValueRange was originally added, and allows for constructing a ValueRange from the arguments of a block.

[ftynse]

Thanks, River!

mlir/include/mlir/IR/FunctionSupport.h

unsigned getNumResults() {
     return static_cast<ConcreteType *>(this)->getNumFuncResults();
   }
 
   /// Gets argument.
   BlockArgument getArgument(unsigned idx) {
     return getBlocks().front().getArgument(idx);
   }
 
-  // Supports non-const operand iteration.
+  /// Support argument iteration.
   using args_iterator = Block::args_iterator;
   args_iterator args_begin() { return front().args_begin(); }
   args_iterator args_end() { return front().args_end(); }
-  iterator_range<args_iterator> getArguments() {
-    return {args_begin(), args_end()};
-  }
+  Block::BlockArgListType getArguments() { return front().getArguments(); }
 
   //===--------------------------------------------------------------------===//
   // Argument Attributes
   //===--------------------------------------------------------------------===//
 
   /// FunctionLike operations allow for attaching attributes to each of the
   /// respective function arguments. These argument attributes are stored as
   /// DictionaryAttrs in the main operation attribute dictionary. The name of

mlir/include/mlir/IR/OperationSupport.h

public:
   ValueRange(Arg &&arg) : ValueRange(ArrayRef<Value>(std::forward<Arg>(arg))) {}
   ValueRange(const Value &value) : ValueRange(&value, /*count=*/1) {}
   ValueRange(const std::initializer_list<Value> &values)
       : ValueRange(ArrayRef<Value>(values)) {}
   ValueRange(iterator_range<OperandRange::iterator> values)
       : ValueRange(OperandRange(values)) {}
   ValueRange(iterator_range<ResultRange::iterator> values)
       : ValueRange(ResultRange(values)) {}
+  ValueRange(ArrayRef<BlockArgument> values)
+      : ValueRange(ArrayRef<Value>(values.data(), values.size())) {}
   ValueRange(ArrayRef<Value> values = llvm::None);
   ValueRange(OperandRange values);
   ValueRange(ResultRange values);
 
   /// Returns the types of the values within this range.
   using type_iterator = ValueTypeIterator<iterator>;
   iterator_range<type_iterator> getTypes() const { return {begin(), end()}; }
 

mlir/lib/Dialect/LoopOps/LoopOps.cpp

static ParseResult parseParallelOp(OpAsmParser &parser,
 
   // Add a terminator if none was parsed.
   ForOp::ensureTerminator(*body, builder, result.location);
 
   return success();
 }
 
 static void print(OpAsmPrinter &p, ParallelOp op) {
-  p << op.getOperationName() << " (";
-  p.printOperands(op.getBody()->getArguments());
-  p << ") = (" << op.lowerBound() << ") to (" << op.upperBound() << ") step ("
-    << op.step() << ")";
+  p << op.getOperationName() << " (" << op.getBody()->getArguments() << ") = ("
+    << op.lowerBound() << ") to (" << op.upperBound() << ") step (" << op.step()
+    << ")";
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
   p.printOptionalAttrDict(op.getAttrs());
   if (!op.results().empty())
     p << " : " << op.getResultTypes();
 }
 
 ParallelOp mlir::loop::getParallelForInductionVarOwner(Value val) {
   auto ivArg = val.dyn_cast<BlockArgument>();

mlir/test/EDSC/builder-api-test.cpp

auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
                        ShapedType::kDynamicSize, ShapedType::kDynamicSize},
                       f32Type, {}, 0);
   auto f = makeFunction("linalg_dilated_conv_nhwc", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  linalg_dilated_conv_nhwc(
-      makeValueHandles(llvm::to_vector<3>(f.getArguments())),
+  linalg_dilated_conv_nhwc(makeValueHandles(f.getArguments()),
                            /*depth_multiplier=*/7,
                            /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_metadata_ops
 //       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<4x8x16xf32> into memref<32x16xf32>