[mlir][Linalg] Let FuseIntoContainingOp return success when nothing is fused.

[nicolasvasilache]

Summary

This composes better when the op is applied in situations where it does not match.

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

cloneAndFuse(Operation *producerOp, Operation *containingOp,
   return fusedOps;
 }
 
 DiagnosedSilenceableFailure
 transform::FuseIntoContainingOp::apply(transform::TransformResults &results,
                                        transform::TransformState &state) {
   SmallVector<Operation *> fusedOps;
   ArrayRef<Operation *> producerOps = state.getPayloadOps(getProducerOp());
+  // If nothing to fuse, propagate success.
+  if (producerOps.empty()) {
+    results.set(getResult().cast<OpResult>(), SmallVector<mlir::Operation *>{});
+    return DiagnosedSilenceableFailure::success();
+  }
   for (Operation *producerOp : producerOps) {
     if (producerOp->getNumResults() != 1) {
       Diagnostic diag(producerOp->getLoc(), DiagnosticSeverity::Note);
       diag << "op with != 1 results not supported";
       return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
     }
   }
   ArrayRef<Operation *> containingOps = state.getPayloadOps(getContainingOp());
   if (containingOps.size() != 1)
     return DiagnosedSilenceableFailure(
-        this->emitOpError("requires exactly one containing_op handle"));
+        this->emitOpError("requires exactly one containing_op handle (got ")
+        << containingOps.size() << ")");
   Operation *containingOp = containingOps.front();
 
   // Helper function to find the next producer that should be fused. Take any
   // producer that has a use inside the containing op.
   SmallVector<Operation *> remainingProducers(producerOps.begin(),
                                               producerOps.end());
   auto getNextProducer = [&]() -> FailureOr<Operation *> {
     for (const auto &it : enumerate(remainingProducers)) {

mlir/test/Dialect/Linalg/transform-op-fuse-into-containing.mlir

%2 = scf.foreach_thread (%arg3) in (%1)  -> (tensor<?xf32>) {
       scf.foreach_thread.perform_concurrently {
         tensor.parallel_insert_slice %7 into %arg2[%3] [%4] [1] : tensor<?xf32> into tensor<?xf32>
       }
     }
     // CHECK: }
     func.return %2 : tensor<?xf32>
   }
 
+  // Check no failure when nothing happens.
+  func.func @dummy1() { return }
+  func.func @dummy2() { return }
+  func.func @dummy3() { return }
+
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
     transform.sequence %arg0 {
     ^bb1(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.fill"]} in %arg1
       %1 = transform.structured.match ops{["scf.foreach_thread"]} in %arg1
 
       // linalg.fill is tileable. The op is tiled and fused.