[MLIR] [NFC] Use llvm::hasSingleElement() in place of .size() == 1

[jurahul]

Summary

• Also use functions in the Region class instead of Region::getBlocks() where possible.

[rriddle]

Thanks!

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

void LaunchOp::build(OpBuilder &builder, OperationState &result,
   Region *kernelRegion = result.addRegion();
   Block *body = new Block();
   body->addArguments(
       std::vector<Type>(kNumConfigRegionAttributes, builder.getIndexType()));
   kernelRegion->push_back(body);
 }
 
 KernelDim3 LaunchOp::getBlockIds() {
-  assert(!body().getBlocks().empty() && "FuncOp body must not be empty.");
+  assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getBlocks().front().getArguments();
   return KernelDim3{args[0], args[1], args[2]};
 }
 
 KernelDim3 LaunchOp::getThreadIds() {
-  assert(!body().getBlocks().empty() && "FuncOp body must not be empty.");
+  assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getBlocks().front().getArguments();
   return KernelDim3{args[3], args[4], args[5]};
 }
 
 KernelDim3 LaunchOp::getGridSize() {
-  assert(!body().getBlocks().empty() && "FuncOp body must not be empty.");
+  assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getBlocks().front().getArguments();
   return KernelDim3{args[6], args[7], args[8]};
 }
 
 KernelDim3 LaunchOp::getBlockSize() {
-  assert(!body().getBlocks().empty() && "FuncOp body must not be empty.");
+  assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getBlocks().front().getArguments();
   return KernelDim3{args[9], args[10], args[11]};
 }
 
 KernelDim3 LaunchOp::getGridSizeOperandValues() {
   return KernelDim3{getOperand(0), getOperand(1), getOperand(2)};
 }
 

mlir/lib/Dialect/Linalg/EDSC/Builders.cpp

Operation *mlir::edsc::makeGenericLinalgOp(
   assert(op->getNumRegions() == 1);
   assert(op->getRegion(0).empty());
   OpBuilder opBuilder(op);
   ScopedContext scope(opBuilder, op->getLoc());
   BlockHandle b;
   SmallVector<Value, 8> handles(blockTypes.size());
   BlockBuilder(&b, op->getRegion(0), blockTypes,
                handles)([&] { regionBuilder(b.getBlock()->getArguments()); });
-  assert(op->getRegion(0).getBlocks().size() == 1);
+  assert(llvm::hasSingleElement(op->getRegion(0)));
   return op;
 }
 
 void mlir::edsc::ops::mulRegionBuilder(ArrayRef<BlockArgument> args) {
   using edsc::op::operator+;
   using edsc::op::operator*;
   assert(args.size() == 2 && "expected 2 block arguments");
   Value a(args[0]), b(args[1]);

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static LogicalResult verifyGenericOp(GenericOpType op) {
   auto nLoops = op.getNumLoops();
   auto nInputsAndOutputBuffers = op.getNumInputsAndOutputBuffers();
   if (nInputsAndOutputBuffers != llvm::size(op.views()))
     return op.emitOpError("expected exactly ")
            << nInputsAndOutputBuffers
            << " inputs (tensor or buffer) and output buffer operands";
 
   auto &region = op.region();
-  if (region.getBlocks().size() != 1)
+  if (!llvm::hasSingleElement(region))
     return op.emitOpError("expected region with 1 block");
   if (failed(BlockArgsVerifier<GenericOpType>::verify(op, region.front())))
     return failure();
 
   SmallVector<AffineMap, 4> indexingMaps;
   indexingMaps.reserve(op.indexing_maps().size());
   for (auto en : llvm::enumerate(op.indexing_maps())) {
     auto idx = en.index();

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

static void transformIndexedGenericOpIndices(
   // inserted in the loop body in that case.
   //
   // TODO(pifon): Add support for `linalg.indexed_generic` with `fun` attribute.
   auto &region = indexedGenericOp.region();
   if (region.empty()) {
     indexedGenericOp.emitOpError("expected a region");
     return;
   }
-  auto &block = region.getBlocks().front();
+  auto &block = region.front();
 
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPointToStart(&block);
   for (unsigned i = 0; i < indexedGenericOp.getNumLoops(); ++i) {
     auto rangeIndex = loopIndexToRangeIndex.find(i);
     if (rangeIndex == loopIndexToRangeIndex.end())
       continue;
     Value oldIndex = block.getArgument(i);

mlir/lib/Transforms/LoopFusion.cpp

 // Initializes the data dependence graph by walking operations in 'f'.
 // Assigns each node in the graph a node id based on program order in 'f'.
 // TODO(andydavis) Add support for taking a Block arg to construct the
 // dependence graph at a different depth.
 bool MemRefDependenceGraph::init(FuncOp f) {
   DenseMap<Value, SetVector<unsigned>> memrefAccesses;
 
   // TODO: support multi-block functions.
-  if (f.getBlocks().size() != 1)
+  if (!llvm::hasSingleElement(f))
     return false;
 
   DenseMap<Operation *, unsigned> forToNodeMap;
   for (auto &op : f.front()) {
     if (auto forOp = dyn_cast<AffineForOp>(op)) {
       // Create graph node 'id' to represent top-level 'forOp' and record
       // all loads and store accesses it contains.
       LoopNestStateCollector collector;

mlir/lib/Transforms/MemRefDataFlowOpt.cpp

void MemRefDataFlowOpt::forwardStoreToLoad(AffineLoadOp loadOp) {
   memrefsToErase.insert(loadOp.getMemRef());
   // Record this to erase later.
   loadOpsToErase.push_back(loadOp);
 }
 
 void MemRefDataFlowOpt::runOnFunction() {
   // Only supports single block functions at the moment.
   FuncOp f = getFunction();
-  if (f.getBlocks().size() != 1) {
+  if (!llvm::hasSingleElement(f)) {
     markAllAnalysesPreserved();
     return;
   }
 
   domInfo = &getAnalysis<DominanceInfo>();
   postDomInfo = &getAnalysis<PostDominanceInfo>();
 
   loadOpsToErase.clear();

mlir/lib/Transforms/ViewOpGraph.cpp

for (Operation &op : module) {
       if (auto nestedModule = dyn_cast<ModuleOp>(op)) {
         processModule(nestedModule);
         continue;
       }
       auto opName = getOpName(op);
       for (Region &region : op.getRegions()) {
         for (auto indexed_block : llvm::enumerate(region)) {
           // Suffix block number if there are more than 1 block.
-          auto blockName = region.getBlocks().size() == 1
+          auto blockName = llvm::hasSingleElement(region)
                                ? ""
                                : ("__" + llvm::utostr(indexed_block.index()));
           llvm::WriteGraph(os, &indexed_block.value(), short_names,
                            Twine(title) + opName + blockName);
         }
       }
     }
   }

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

 }
 
 void VectorizerTestPass::runOnFunction() {
   // Thread-safe RAII local context, BumpPtrAllocator freed on exit.
   NestedPatternContext mlContext;
 
   // Only support single block functions at this point.
   FuncOp f = getFunction();
-  if (f.getBlocks().size() != 1)
+  if (!llvm::hasSingleElement(f))
     return;
 
   std::string str;
   llvm::raw_string_ostream outs(str);
 
   if (!clTestVectorShapeRatio.empty())
     testVectorShapeRatio(outs);