[mlir][Transform] Fix transform.sequence crash in the presence of propagated silenceable errors and yield operations

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

void transform::AlternativesOp::getRegionInvocationBounds(
   (void)operands;
   // The region corresponding to the first alternative is always executed, the
   // remaining may or may not be executed.
   bounds.reserve(getNumRegions());
   bounds.emplace_back(1, 1);
   bounds.resize(getNumRegions(), InvocationBounds(0, 1));
 }
 
+static void forwardEmptyOperands(Block *block, transform::TransformState &state,
+                                 transform::TransformResults &results) {
+  for (const auto &res : block->getParentOp()->getOpResults())
+    results.set(res, {});
+}
+
 static void forwardTerminatorOperands(Block *block,
                                       transform::TransformState &state,
                                       transform::TransformResults &results) {
   for (const auto &pair : llvm::zip(block->getTerminator()->getOperands(),
                                     block->getParentOp()->getOpResults())) {
     Value terminatorOperand = std::get<0>(pair);
     OpResult result = std::get<1>(pair);
     results.set(result, state.getPayloadOps(terminatorOperand));
transform::SequenceOp::apply(transform::TransformResults &results,
   // Apply the sequenced ops one by one.
   for (Operation &transform : getBodyBlock()->without_terminator()) {
     DiagnosedSilenceableFailure result =
         state.applyTransform(cast<TransformOpInterface>(transform));
     if (result.isDefiniteFailure())
       return result;
 
     if (result.isSilenceableFailure()) {
-      if (getFailurePropagationMode() == FailurePropagationMode::Propagate)
+      if (getFailurePropagationMode() == FailurePropagationMode::Propagate) {
+        // Propagate empty results in case of early exit.
+        forwardEmptyOperands(getBodyBlock(), state, results);
         return result;
+      }
       (void)result.silence();
     }
   }
 
   // Forward the operation mapping for values yielded from the sequence to the
   // values produced by the sequence op.
   forwardTerminatorOperands(getBodyBlock(), state, results);
   return DiagnosedSilenceableFailure::success();

mlir/test/Dialect/Transform/test-interpreter.mlir

^bb0(%arg0: !pdl.operation):
 
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operation "test.some_op"
     pdl.rewrite %0 with "transform.dialect"
   }
 }
 
 "test.some_op"() : () -> ()
+// -----
+
+func.func @split_handles(%a: index, %b: index, %c: index) {
+  %0 = arith.muli %a, %b : index  
+  %1 = arith.muli %a, %c : index  
+  return
+}
+
+transform.sequence -> !pdl.operation failures(propagate) {
+^bb1(%fun: !pdl.operation):
+  %muli = transform.structured.match ops{["arith.muli"]} in %fun
+  // expected-error @below {{expected to contain 3 operation handles but it only contains 2 handles}}
+  %h_2:3 = split_handles %muli in [3] : (!pdl.operation) -> (!pdl.operation, !pdl.operation, !pdl.operation)
+  /// Test that yield does not crash in the presence of silenceable error in
+  /// propagate mode.
+  yield %fun : !pdl.operation
+}