Added CallOpSignatureConversion pattern

[rsuderman]

Summary

Added a corresponding conversion pattern for CallOp to match FuncOp. Currently
if just FuncOp is converted, CallOp is not correctly updated. This ensures CallOp
and FuncOp can have their types converted.

[rriddle]

Thanks for the patch Rob, this looks like it would be useful for many different users of CallOp!

Can we add a test for this?

mlir/include/mlir/Transforms/DialectConversion.h

369

Can we move this to a library specific to the StandardDialect? I'd like for us to keep DialectConversion as dialect agnostic as we can. I added FuncOp here because it's technically builtin(defined in IR/) at the moment.

mlir/lib/Transforms/DialectConversion.cpp

1780

Can we use operands here instead?

[benvanik]

mlir/lib/Transforms/DialectConversion.cpp

1780

+1 - operands must be used here

1781

the create and replace can be done together:

rewriter.replaceOpWithNewOp<CallOp>(callOp, callOp.callee(),
                                    convertedResults, operands);

mlir/include/mlir/Transforms/DialectConversion.h

 };
 
 /// Add a pattern to the given pattern list to convert the signature of a FuncOp
 /// with the given type converter.
 void populateFuncOpTypeConversionPattern(OwningRewritePatternList &patterns,
                                          MLIRContext *ctx,
                                          TypeConverter &converter);
 
+/// Add a pattern to the given pattern list to convert the result types of a
+/// CallOp with the given type converter.
+void populateCallOpTypeConversionPattern(OwningRewritePatternList &patterns,
+                                         MLIRContext *ctx,
+                                         TypeConverter &converter);
+
 //===----------------------------------------------------------------------===//
 // Conversion PatternRewriter
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct ConversionPatternRewriterImpl;
 } // end namespace detail
 

mlir/lib/Transforms/DialectConversion.cpp

 } // end anonymous namespace
 
 void mlir::populateFuncOpTypeConversionPattern(
     OwningRewritePatternList &patterns, MLIRContext *ctx,
     TypeConverter &converter) {
   patterns.insert<FuncOpSignatureConversion>(ctx, converter);
 }
 
+/// Create a default conversion pattern that rewrites the result type of a
+/// CallOp
+namespace {
+
+struct CallOpSignatureConversion : public OpConversionPattern<CallOp> {
+  CallOpSignatureConversion(MLIRContext *ctx, TypeConverter &converter)
+      : OpConversionPattern(ctx), converter(converter) {}
+
+  /// Hook for derived classes to implement combined matching and rewriting.
+  PatternMatchResult
+  matchAndRewrite(CallOp callOp, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    FunctionType type = callOp.getCalleeType();
+
+    // Convert the original function results.
+    SmallVector<Type, 1> convertedResults;
+    if (failed(converter.convertTypes(type.getResults(), convertedResults)))
+      return matchFailure();
+
+    // Substitute with the new result types from the corresponding FuncType
+    // conversion.
+    auto newCallOp =
+        rewriter.create<CallOp>(callOp.getLoc(), callOp.callee(),
+                                convertedResults, callOp.getArgOperands());
+    rewriter.replaceOp(callOp, newCallOp.getResults());
+    return matchSuccess();
+  }
+
+  /// The type converter to use when rewriting the signature.
+  TypeConverter &converter;
+};
+
+} // end anonymous namespace
+
+void mlir::populateCallOpTypeConversionPattern(
+    OwningRewritePatternList &patterns, MLIRContext *ctx,
+    TypeConverter &converter) {
+  patterns.insert<CallOpSignatureConversion>(ctx, converter);
+}
+
 /// This function converts the type signature of the given block, by invoking
 /// 'convertSignatureArg' for each argument. This function should return a valid
 /// conversion for the signature on success, None otherwise.
 auto TypeConverter::convertBlockSignature(Block *block)
     -> Optional<SignatureConversion> {
   SignatureConversion conversion(block->getNumArguments());
   for (unsigned i = 0, e = block->getNumArguments(); i != e; ++i)
     if (failed(convertSignatureArg(i, block->getArgument(i).getType(),