[mlir][scf] Make whileOp builder funcs optional

[Hardcode84]

Summary

Create empty block without the terminator in this case.

[Hardcode84]

Some notes:

• I cannot do beforeBuilder=nullptr in builder def, because it will conflict with default-generated builder and I cannot remove default builder because it is already being used in ForToWhile pass
• Current behavior is different from ForOp::build which tries to create default terminator in case if it have zero args https://github.com/llvm/llvm-project/blob/e78d341f936e52df92279cc5bff1bff0625b7d23/mlir/lib/Dialect/SCF/IR/SCF.cpp#L313 but I don't like this approach as it will forces to handle these 2 cases differently on user side

[ftynse]

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

3817–3819

Nit: it's possible to update the OpBuilder definition in ODS and use CArg there to produce default values for these.

[Hardcode84]

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

3817–3819

see my previous comment

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

 //===----------------------------------------------------------------------===//
 // WhileOp
 //===----------------------------------------------------------------------===//
 
 void WhileOp::build(::mlir::OpBuilder &odsBuilder,
                     ::mlir::OperationState &odsState, TypeRange resultTypes,
                     ValueRange operands, BodyBuilderFn beforeBuilder,
                     BodyBuilderFn afterBuilder) {
-  assert(beforeBuilder && "the builder callback for 'before' must be present");
-  assert(afterBuilder && "the builder callback for 'after' must be present");
-
   odsState.addOperands(operands);
   odsState.addTypes(resultTypes);
 
   OpBuilder::InsertionGuard guard(odsBuilder);
 
   // Build before region.
   SmallVector<Location, 4> beforeArgLocs;
   beforeArgLocs.reserve(operands.size());
   for (Value operand : operands) {
     beforeArgLocs.push_back(operand.getLoc());
   }
 
   Region *beforeRegion = odsState.addRegion();
   Block *beforeBlock = odsBuilder.createBlock(
       beforeRegion, /*insertPt=*/{}, operands.getTypes(), beforeArgLocs);
+  if (beforeBuilder)
     beforeBuilder(odsBuilder, odsState.location, beforeBlock->getArguments());
 
   // Build after region.
   SmallVector<Location, 4> afterArgLocs(resultTypes.size(), odsState.location);
 
   Region *afterRegion = odsState.addRegion();
   Block *afterBlock = odsBuilder.createBlock(afterRegion, /*insertPt=*/{},
                                              resultTypes, afterArgLocs);
+
+  if (afterBuilder)
     afterBuilder(odsBuilder, odsState.location, afterBlock->getArguments());
 }
 
 OperandRange WhileOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
   assert(index && *index == 0 &&
          "WhileOp is expected to branch only to the first region");
 
   return getInits();
 }
for (auto arg : condOpArgs) {
         newArgs.emplace_back(arg);
       }
     }
 
     if (argsMap.size() == condOpArgs.size())
       return rewriter.notifyMatchFailure(op, "No results to remove");
 
     ValueRange argsRange(newArgs);
-    auto emptyBuilder = [](OpBuilder &, Location, ValueRange) {
-      // Nothing
-    };
 
     Location loc = op.getLoc();
     auto newWhileOp = rewriter.create<scf::WhileOp>(
-        loc, argsRange.getTypes(), op.getInits(), emptyBuilder, emptyBuilder);
+        loc, argsRange.getTypes(), op.getInits(), /*beforeBody*/ nullptr,
+        /*afterBody*/ nullptr);
     Block &newBeforeBlock = newWhileOp.getBefore().front();
     Block &newAfterBlock = newWhileOp.getAfter().front();
 
     SmallVector<Value> afterArgsMapping;
     SmallVector<Value> resultsMapping;
     for (auto &&[i, arg] : llvm::enumerate(condOpArgs)) {
       auto it = argsMap.find(arg);
       assert(it != argsMap.end());
       auto pos = it->second;
for (auto &&[arg, init, yieldArg] : llvm::zip(
       newYieldArgs.emplace_back(yieldArg);
     }
 
     if (!changed)
       return rewriter.notifyMatchFailure(op, "No args to remove");
 
     beforeBlock.eraseArguments(argsToRemove);
 
-    auto emptyBuilder = [](OpBuilder &, Location, ValueRange) {
-      // Nothing
-    };
-
     Location loc = op.getLoc();
-    auto newWhileOp = rewriter.create<WhileOp>(
-        loc, op->getResultTypes(), newInits, emptyBuilder, emptyBuilder);
+    auto newWhileOp =
+        rewriter.create<WhileOp>(loc, op->getResultTypes(), newInits,
+                                 /*beforeBody*/ nullptr, /*afterBody*/ nullptr);
     Block &newBeforeBlock = newWhileOp.getBefore().front();
     Block &newAfterBlock = newWhileOp.getAfter().front();
 
     OpBuilder::InsertionGuard g(rewriter);
     rewriter.setInsertionPoint(yield);
     rewriter.replaceOpWithNewOp<YieldOp>(yield, newYieldArgs);
 
     rewriter.mergeBlocks(&beforeBlock, &newBeforeBlock,