[MLIR] Fix build failures due to unused variables in non-debug builds.

[jurahul]

Summary

As subject.

[GMNGeoffrey]

LGTM

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

 }
 
 /// The following uses internal knowledge of the position of tied operand /
 /// results.
 static void propagateInPlace(const SmallVector<OpOperand *> &initalWorklist,
                              const DominanceInfo &domInfo) {
   LLVM_DEBUG(DBGS() << "\n\n");
   LLVM_DEBUG(DBGS() << "Start propagateInPlace from initial WL\n");
-  for (OpOperand *operand : initalWorklist)
-    LLVM_DEBUG(DBGS() << "WL item: " << operand->get() << " used by "
-                      << *operand->getOwner() << "\n");
+  LLVM_DEBUG(for (OpOperand *operand
+                  : initalWorklist) DBGS()
+             << "WL item: " << operand->get() << " used by "
   SmallVector<OpOperand *> worklist(initalWorklist);
   for (unsigned idx = 0; idx < worklist.size(); ++idx) {
     // TODO: bail on subtensor/subtensor_insert and vector.transfer_read/write
     // that should have been already captured in destructive update patterns?
     OpOperand &operand = *worklist[idx];
     LLVM_DEBUG(DBGS() << "WL item: " << *operand.getOwner() << "\n");
     // If the owner turns out to be a CallOp without
     // `kWriteableFuncBufferArgsAttrName` this will be a noop.
if (isa<FuncOp>(parentOp) && getInPlace(candidate) != InPlaceSpec::True) {
       continue;
     }
 
     llvm::SetVector<Operation *> slice;
     getForwardSlice(candidate, &slice,
                     [&](Operation *op) { return op->getBlock() == block; });
 
     LLVM_DEBUG(DBGS() << "Slice:\n");
-    for (auto *op : slice)
-      LLVM_DEBUG(DBGS() << *op << "\n");
+    LLVM_DEBUG(for (auto *op : slice) DBGS() << *op << "\n");
 
     bool failedDetectingDestructiveUpdate =
         // func / return inplace patterns.
         failed(detectInplaceOpToTerminator<FuncOp, ReturnOp>(
             parentOp, candidate, slice.getArrayRef()));
     if (failedDetectingDestructiveUpdate) {
       LLVM_DEBUG(DBGS() << "Failed to detect a destructive update pattern\n");
       continue;

 
 /// ReturnOp always creates memref::TensorLoadOp.
 static LogicalResult convertReturnOp(OpBuilder &b, ReturnOp returnOp,
                                      BlockAndValueMapping &bvm) {
   // Take a guard before anything else.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(returnOp);
 
-  FuncOp funcOp = cast<FuncOp>(returnOp->getParentOp());
-  assert(funcOp && "only support FuncOp parent for ReturnOp");
+  assert(isa<FuncOp>(returnOp->getParentOp()) &&
+         "only support FuncOp parent for ReturnOp");
   for (OpOperand &operand : returnOp->getOpOperands()) {
     auto tensorType = operand.get().getType().dyn_cast<TensorType>();
     if (!tensorType)
       continue;
     operand.set(b.create<memref::TensorLoadOp>(returnOp.getLoc(),
                                                lookup(bvm, operand.get())));
   }
   return success();