[mlir][IR][NFC] Rename RewriterBase::replaceUseIf to replaceUsesWithIf

[springerm]

Summary

This is for consistency with Value::replaceUsesWithIf.

mlir/include/mlir/IR/PatternMatch.h

for (OperandType &operand : llvm::make_early_inc_range(from->getUses())) {
       Operation *op = operand.getOwner();
       updateRootInPlace(op, [&]() { operand.set(to); });
     }
   }
 
   /// Find uses of `from` and replace them with `to` if the `functor` returns
   /// true. It also marks every modified uses and notifies the rewriter that an
   /// in-place operation modification is about to happen.
-  void replaceUseIf(Value from, Value to,
+  void
+  replaceUsesWithIf(Value from, Value to,
                     llvm::unique_function<bool(OpOperand &) const> functor);
 
   /// Find uses of `from` and replace them with `to` except if the user is
   /// `exceptedUser`. It also marks every modified uses and notifies the
   /// rewriter that an in-place operation modification is about to happen.
   void replaceAllUsesExcept(Value from, Value to, Operation *exceptedUser) {
-    return replaceUseIf(from, to, [&](OpOperand &use) {
+    return replaceUsesWithIf(from, to, [&](OpOperand &use) {
       Operation *user = use.getOwner();
       return user != exceptedUser;
     });
   }
 
   /// Used to notify the rewriter that the IR failed to be rewritten because of
   /// a match failure, and provide a callback to populate a diagnostic with the
   /// reason why the failure occurred. This method allows for derived rewriters

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

for (OpOperand &opOperand : genericOp->getOpOperands()) {
         continue;
 
       FailureOr<ElementwiseOpFusionResult> fusionResult =
           fuseElementwiseOps(rewriter, &opOperand);
       if (failed(fusionResult))
         return rewriter.notifyMatchFailure(genericOp, "fusion failed");
       Operation *producer = opOperand.get().getDefiningOp();
       for (auto [origVal, replacement] : fusionResult->replacements) {
-        rewriter.replaceUseIf(origVal, replacement, [&](OpOperand &use) {
+        rewriter.replaceUsesWithIf(origVal, replacement, [&](OpOperand &use) {
           // Only replace consumer uses.
           return use.get().getDefiningOp() != producer;
         });
       }
       rewriter.eraseOp(genericOp);
       return success();
     }
     return failure();

mlir/lib/IR/PatternMatch.cpp

void RewriterBase::mergeBlocks(Block *source, Block *dest,
   dest->getOperations().splice(dest->end(), source->getOperations());
   source->dropAllUses();
   source->erase();
 }
 
 /// Find uses of `from` and replace them with `to` if the `functor` returns
 /// true. It also marks every modified uses and notifies the rewriter that an
 /// in-place operation modification is about to happen.
-void RewriterBase::replaceUseIf(
+void RewriterBase::replaceUsesWithIf(
     Value from, Value to,
     llvm::unique_function<bool(OpOperand &) const> functor) {
   for (OpOperand &operand : llvm::make_early_inc_range(from.getUses())) {
     if (functor(operand))
       updateRootInPlace(operand.getOwner(), [&]() { operand.set(to); });
   }
 }
 

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

LogicalResult matchAndRewrite(linalg::GenericOp genericOp,
     if (!fusableOperand) {
       return rewriter.notifyMatchFailure(genericOp, "no fusable operand found");
     }
     std::optional<linalg::ElementwiseOpFusionResult> fusionResult =
         linalg::fuseElementwiseOps(rewriter, fusableOperand);
     if (!fusionResult)
       return rewriter.notifyMatchFailure(genericOp, "fusion failed");
     for (auto [origValue, replacement] : fusionResult->replacements) {
-      rewriter.replaceUseIf(origValue, replacement, [&](OpOperand &use) {
+      rewriter.replaceUsesWithIf(origValue, replacement, [&](OpOperand &use) {
         return use.getOwner() != genericOp.getOperation();
       });
     }
     rewriter.eraseOp(genericOp);
     return success();
   }
 };
 

mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp

while (!candidates.empty()) {
       if (auto fusedProducerOp =
               fusedProducer->tiledAndFusedProducer.getDefiningOp())
         addCandidateSlices(fusedProducerOp, candidates);
     }
 
     scf::ForOp outermostLoop = tilingResult->loops.front();
     for (auto [index, origVal] : llvm::enumerate(yieldedValuesToOrigValues)) {
       Value replacement = outermostLoop.getResult(index);
-      rewriter.replaceUseIf(origVal, replacement, [&](OpOperand &use) {
+      rewriter.replaceUsesWithIf(origVal, replacement, [&](OpOperand &use) {
         return !isIgnoredUser(use.getOwner(), outermostLoop);
       });
     }
     rewriter.eraseOp(rootOp);
     filter.replaceLinalgTransformationFilter(rewriter,
                                              tilingResult->tiledOps.back());
     return success();
   }