[MLIR] Fix compiler warnings (NFC)

[chelini]

Summary

In TestTensorTransforms.cpp replaced is nullptr I assumed the intent
was to emit the error for the rootOp.

In TransformInterfaces.cpp there were some uninitialized variables.

In NVGPUTransformOps.cpp matmulOp was never used.

[ftynse]

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

103

This parenthesation is confusing.

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

524–526

Can we rather set something like UINT_MAX here so we immediately see if the "unset" value is used?

[chelini]

Address comment

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

103

Sorry, fixed now.

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

524–526

went for numeric_limits let me know if you prefer UINT_MAX.

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

 /// - dim sizes are multiples of "padToMultipleOf"
 ///
 /// Otherwise, try to pad the shape dimensions that match the iterator
 /// dimensions "paddingDimensions" and return the tensor::PadOp result if
 /// padding succeeds or failure otherwise.
 static FailureOr<Value> padOperandToSmallestStaticBoundingBox(
     RewriterBase &rewriter, linalg::LinalgOp opToPad, OpOperand *opOperand,
     const LinalgPaddingOptions &options) {
-  assert(!options.padToMultipleOf.has_value() ||
-         options.padToMultipleOf->size() == options.paddingDimensions.size() &&
-             "invalid number of elements in padToMultipleOf");
+  assert(
+      (!options.padToMultipleOf.has_value() ||
+       options.padToMultipleOf->size() == options.paddingDimensions.size()) &&
 
   // Compute padded shape.
   SmallVector<int64_t> paddedShape;
   bool alreadyHasRequestedShape = false;
   if (failed(computePaddedShape(opToPad, opOperand, options, paddedShape,
                                 alreadyHasRequestedShape)))
     return rewriter.notifyMatchFailure(opToPad,
                                        "--failed to compute padded shape");

mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp

 }
 
 DiagnosedSilenceableFailure transform::RewriteMatmulAsMmaSyncOp::applyToOne(
     transform::TransformRewriter &rewriter, LinalgOp linalgOp,
     transform::ApplyToEachResultList &results,
     transform::TransformState &state) {
   bool fail = true;
   // TODO: more robust detection of matmulOp, with transposes etc.
-  if (auto matmulOp = isa<linalg::MatmulOp>(linalgOp.getOperation())) {
+  if (isa_and_nonnull<linalg::MatmulOp>(linalgOp.getOperation())) {
     Location loc = linalgOp.getLoc();
     // TODO: more robust computation of laneId, for now assume a single warp.
     Value laneId = rewriter.create<gpu::ThreadIdOp>(
         loc, rewriter.getIndexType(), gpu::Dimension::x);
     if (succeeded(MmaSyncBuilder(rewriter, loc, laneId).buildMmaSync(linalgOp)))
       fail = false;
   }
 

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

void transform::TransformState::recordValueHandleInvalidationByOpHandleOne(
   // invalidation and not the last one.
   if (invalidatedHandles.count(valueHandle) ||
       newlyInvalidated.count(valueHandle))
     return;
 
   for (Operation *ancestor : potentialAncestors) {
     Operation *definingOp;
     std::optional<unsigned> resultNo;
-    unsigned argumentNo, blockNo, regionNo;
+    unsigned argumentNo = std::numeric_limits<unsigned>::max();
+    unsigned blockNo = std::numeric_limits<unsigned>::max();
+    unsigned regionNo = std::numeric_limits<unsigned>::max();
     if (auto opResult = llvm::dyn_cast<OpResult>(payloadValue)) {
       definingOp = opResult.getOwner();
       resultNo = opResult.getResultNumber();
     } else {
       auto arg = llvm::cast<BlockArgument>(payloadValue);
       definingOp = arg.getParentBlock()->getParentOp();
       argumentNo = arg.getArgNumber();
       blockNo = std::distance(arg.getOwner()->getParent()->begin(),

mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

if (op->hasAttr("replaced")) {
       }
       replaced = op;
     }
     return WalkResult::advance();
   });
   if (status.wasInterrupted())
     return failure();
   if (!replaced) {
-    replaced->emitError("could not find 'replaced' op");
+    rootOp->emitError("could not find 'replaced' op");
     return failure();
   }
 
   // Find replacements.
   SmallVector<Value> replacements(replaced->getNumResults(), Value());
   status = rootOp->walk([&](Operation *op) {
     for (int64_t i = 0; i < replaced->getNumResults(); ++i) {
       if (auto attr = op->getAttrOfType<IntegerAttr>("replacement_" +