[MLIR][NFC] Adopt use of BlockRange in place of ArrayRef<Block *>

[jurahul]

Summary

• Use BlockRange in ODS generated builders as well as other places throughout the code

Depends On D87944

[mehdi_amini]

Thanks!

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

def PDLInterp_SwitchAttributeOp
   let arguments = (ins PDL_Attribute:$attribute, ArrayAttr:$caseValues);
   let assemblyFormat = [{
     $attribute `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, Value attribute,"
               "ArrayRef<Attribute> caseValues,"
-              "Block *defaultDest, ArrayRef<Block *> dests", [{
+              "Block *defaultDest, BlockRange dests", [{
     build(builder, state, attribute, builder.getArrayAttr(caseValues),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
def PDLInterp_SwitchOperandCountOp
   let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
               "ArrayRef<int32_t> counts, Block *defaultDest, "
-              "ArrayRef<Block *> dests", [{
+              "BlockRange dests", [{
     build(builder, state, operation, builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperationNameOp
 //===----------------------------------------------------------------------===//
let arguments = (ins PDL_Operation:$operation,
                        StrArrayAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
               "ArrayRef<OperationName> names, "
-              "Block *defaultDest, ArrayRef<Block *> dests", [{
+              "Block *defaultDest, BlockRange dests", [{
       auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
           [](OperationName name) { return name.getStringRef(); }));
       build(builder, state, operation, builder.getStrArrayAttr(stringNames),
             defaultDest, dests);
     }]>,
   ];
 }
 
def PDLInterp_SwitchResultCountOp
   let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
               "ArrayRef<int32_t> counts, Block *defaultDest, "
-              "ArrayRef<Block *> dests", [{
+              "BlockRange dests", [{
     build(builder, state, operation, builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypeOp
 //===----------------------------------------------------------------------===//
def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
 
   let arguments = (ins PDL_Type:$value, TypeArrayAttr:$caseValues);
   let assemblyFormat = [{
     $value `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, Value edge, "
-              "TypeRange types, Block *defaultDest, ArrayRef<Block *> dests", [{
+              "TypeRange types, Block *defaultDest, BlockRange dests", [{
       build(builder, state, edge, builder.getTypeArrayAttr(types), defaultDest,
             dests);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
   }];
 }
 
 #endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS

mlir/include/mlir/IR/OperationSupport.h

 // classes build on top of.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPERATION_SUPPORT_H
 #define MLIR_IR_OPERATION_SUPPORT_H
 
 #include "mlir/IR/Attributes.h"
+#include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <memory>
 
 namespace mlir {
-class Block;
-class BlockRange;
 class Dialect;
 class Operation;
 struct OperationState;
 class OpAsmParser;
 class OpAsmParserResult;
 class OpAsmPrinter;
 class OperandRange;
 class OpFoldResult;
struct OperationState {
   SmallVector<std::unique_ptr<Region>, 1> regions;
 
 public:
   OperationState(Location location, StringRef name);
 
   OperationState(Location location, OperationName name);
 
   OperationState(Location location, StringRef name, ValueRange operands,
-                 ArrayRef<Type> types, ArrayRef<NamedAttribute> attributes,
-                 ArrayRef<Block *> successors = {},
+                 TypeRange types, ArrayRef<NamedAttribute> attributes,
+                 BlockRange successors = {},
                  MutableArrayRef<std::unique_ptr<Region>> regions = {});
 
   void addOperands(ValueRange newOperands);
 
   void addTypes(ArrayRef<Type> newTypes) {
     types.append(newTypes.begin(), newTypes.end());
   }
   template <typename RangeT>

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

 ///
 /// SPIR-V spec "2.16.1. Universal Validation Rules" requires that "the order
 /// of blocks in a function must satisfy the rule that blocks appear before
 /// all blocks they dominate." This can be achieved by a pre-order CFG
 /// traversal algorithm. To make the serialization output more logical and
 /// readable to human, we perform depth-first CFG traversal and delay the
 /// serialization of the merge block and the continue block, if exists, until
 /// after all other blocks have been processed.
-static LogicalResult visitInPrettyBlockOrder(
-    Block *headerBlock, function_ref<LogicalResult(Block *)> blockHandler,
-    bool skipHeader = false, ArrayRef<Block *> skipBlocks = {}) {
+static LogicalResult
+visitInPrettyBlockOrder(Block *headerBlock,
+                        function_ref<LogicalResult(Block *)> blockHandler,
+                        bool skipHeader = false, BlockRange skipBlocks = {}) {
   llvm::df_iterator_default_set<Block *, 4> doneBlocks;
   doneBlocks.insert(skipBlocks.begin(), skipBlocks.end());
 
   for (Block *block : llvm::depth_first_ext(headerBlock, doneBlocks)) {
     if (skipHeader && block == headerBlock)
       continue;
     if (failed(blockHandler(block)))
       return failure();

mlir/lib/IR/OperationSupport.cpp

 
 OperationState::OperationState(Location location, StringRef name)
     : location(location), name(name, location->getContext()) {}
 
 OperationState::OperationState(Location location, OperationName name)
     : location(location), name(name) {}
 
 OperationState::OperationState(Location location, StringRef name,
-                               ValueRange operands, ArrayRef<Type> types,
+                               ValueRange operands, TypeRange types,
                                ArrayRef<NamedAttribute> attributes,
-                               ArrayRef<Block *> successors,
+                               BlockRange successors,
                                MutableArrayRef<std::unique_ptr<Region>> regions)
     : location(location), name(name, location->getContext()),
       operands(operands.begin(), operands.end()),
       types(types.begin(), types.end()),
       attributes(attributes.begin(), attributes.end()),
       successors(successors.begin(), successors.end()) {
   for (std::unique_ptr<Region> &r : regions)
     this->regions.push_back(std::move(r));

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

if (argument.is<tblgen::NamedTypeConstraint *>()) {
       }
       paramList.emplace_back(type, namedAttr.name, defaultValue, properties);
       ++numAttrs;
     }
   }
 
   /// Insert parameters for each successor.
   for (const NamedSuccessor &succ : op.getSuccessors()) {
-    StringRef type = succ.isVariadic() ? "::llvm::ArrayRef<::mlir::Block *>"
-                                       : "::mlir::Block *";
+    StringRef type =
+        succ.isVariadic() ? "::mlir::BlockRange" : "::mlir::Block *";
     paramList.emplace_back(type, succ.name);
   }
 
   /// Insert parameters for variadic regions.
   for (const NamedRegion &region : op.getRegions())
     if (region.isVariadic())
       paramList.emplace_back("unsigned",
                              llvm::formatv("{0}Count", region.name).str());
void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
   body << "{\n";
   body << "    unsigned index = 0; (void)index;\n";
 
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const auto &successor = op.getSuccessor(i);
     if (successor.constraint.getPredicate().isNull())
       continue;
 
-    body << "    for (::mlir::Block *successor : ";
-    body << formatv(successor.isVariadic()
-                        ? "{0}()"
-                        : "::llvm::ArrayRef<::mlir::Block *>({0}())",
+    if (successor.isVariadic()) {
+      body << formatv("    for (::mlir::Block *successor : {0}()) {\n",
                       successor.name);
-    body << ") {\n";
+    } else {
+      body << "    {\n";
+      body << formatv("      ::mlir::Block *successor = {0}();\n",
+                      successor.name);
+    }
     auto constraint = tgfmt(successor.constraint.getConditionTemplate(),
                             &verifyCtx.withSelf("successor"))
                           .str();
 
     body << formatv("      (void)successor;\n"
                     "      if (!({0})) {\n        "
                     "return emitOpError(\"successor #\") << index << \"('{1}') "
                     "failed to "