[mlir] fail gracefull in CallOpSignatureConversion

[ftynse]

Summary

Previously, the CallOpSignatureConversion pattern would assert if
function signature change affected the number of results. Fail the
pattern instead and let the caller propagate failure.

Fixes #60186.

[mehdi_amini]

Thanks!

mlir/lib/Dialect/Func/Transforms/FuncConversions.cpp

struct CallOpSignatureConversion : public OpConversionPattern<CallOp> {
   matchAndRewrite(CallOp callOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Convert the original function results.
     SmallVector<Type, 1> convertedResults;
     if (failed(typeConverter->convertTypes(callOp.getResultTypes(),
                                            convertedResults)))
       return failure();
 
+    // If this isn't a one-to-one type mapping, we don't know how to aggregate
+    // the results.
+    if (callOp->getNumResults() != convertedResults.size())
+      return failure();
+
     // Substitute with the new result types from the corresponding FuncType
     // conversion.
     rewriter.replaceOpWithNewOp<CallOp>(
         callOp, callOp.getCallee(), convertedResults, adaptor.getOperands());
     return success();
   }
 };
 } // namespace

mlir/test/Transforms/test-legalizer.mlir

 
 // The "passthrough_fold" folder will naively return its operand, but we don't
 // want to fold here because of the type mismatch.
 func.func @typemismatch(%arg: f32) -> i32 {
   // expected-remark@+1 {{op 'test.passthrough_fold' is not legalizable}}
   %0 = "test.passthrough_fold"(%arg) : (f32) -> (i32)
   "test.return"(%0) : (i32) -> ()
 }
+
+// -----
+
+// expected-remark @below {{applyPartialConversion failed}}
+module {
+  func.func private @callee(%0 : f32) -> f32
+
+  func.func @caller( %arg: f32) {
+    // expected-error @below {{failed to legalize}}
+    %1 = func.call @callee(%arg) : (f32) -> f32
+    return
+  }
+}