[mlir] Implement pass utils for 1:N type conversions.

[ingomueller-net]

Summary

The current dialect conversion does not support 1:N type conversions.
This commit implements a (poor-man's) dialect conversion pass that does
just that. To keep the pass independent of the "real" dialect conversion
infrastructure, it provides a specialization of the TypeConverter class
that allows for N:1 target materializations, a specialization of the
RewritePattern and PatternRewriter classes that automatically add
appropriate unrealized casts supporting 1:N type conversions and provide
converted operands for implementing subclasses, and a conversion driver
that applies the provided patterns and replaces the unrealized casts
that haven't folded away with user-provided materializations.

The current pass is powerful enough to express many existing manual
solutions for 1:N type conversions or extend transforms that previously
didn't support them, out of which this patch implements call graph type
decomposition (which is currently implemented with a ValueDecomposer
that is only used there).

The goal of this pass is to illustrate the effect that 1:N type
conversions could have, gain experience in how patterns should be
written that achieve that effect, and get feedback on how the APIs of
the dialect conversion should be extended or changed to support such
patterns. The hope is that the "real" dialect conversion eventually
supports such patterns, at which point, this pass could be removed
again.

[ingomueller-net]

Backport improvements in response to a review from @ftynse made here: https://github.com/iree-org/iree-llvm-sandbox/pull/655.

[ingomueller-net]

Add missing changes in last revision. (I messed up using patch to port the changes from one repo to the other.)

[ingomueller-net]

Remove SCF conversions and tests to avoid distractions.

[ingomueller-net]

Improve comments for test patterns and test pass.

[ingomueller-net]

I have also implemented a decomposition of complex<T> to T, T and extended the test cases of StandardToComplex to run the decomposition either before or after that pass here: https://reviews.llvm.org/D145501. The fact both order produce the same result shows that the 1:N type conversion composes cleanly with other transforms.

[Mogball]

mlir/test/lib/Conversion/OneToNTypeConversion/TestOneToNTypeConversionPass.cpp

22

Test passes should be define in mlir/test/lib/

[ingomueller-net]

mlir/test/lib/Conversion/OneToNTypeConversion/TestOneToNTypeConversionPass.cpp

22

I don't understand. Isn't that the path were the pass is defined already?

[ingomueller-net]

Add diagnostics when user materialization fails.

[ingomueller-net]

Minor: fix order of CHECK matches in test case.

[ingomueller-net]

A few minor updates back-ported from https://github.com/iree-org/iree-llvm-sandbox/pull/655:

• Replace SmallVector<Value> by ValueRange in more parts of the API.
• Use ValueRange instead of SmallVector for a few temporaries.
• Fix typo in comment (NFC).

[ingomueller-net]

After talking to @ftynse, I am moving the main implementation back out of test into Transforms/Utils.

Also fixed an error about an global constructor/destructor.

[ingomueller-net]

I have made several passes over the patch with @ftynse. I believe we came to the conclusion that current patch is in line with the discussion on discourse and more or less ready to land. I'll wait a few more days for anybody else to object or suggest further improvements.

[springerm]

mlir/include/mlir/Dialect/Func/Transforms/OneToNFuncConversions.h

20 ↗

(On Diff #506545)

nit: put in backticks

mlir/include/mlir/Transforms/OneToNTypeConversion.h

12 ↗

(On Diff #506545)

what the "main" function?

42 ↗

(On Diff #506545)

nit: Add documentation for this this callback, e.g., when is it used.

55 ↗

(On Diff #506545)

Can there be multiple materializations? What happens in that case? Is this consistent with the 1:1 type converter?

69 ↗

(On Diff #506545)

nit: I've seen mostly uses without a size hint recently.

186 ↗

(On Diff #506545)

typo

187 ↗

(On Diff #506545)

function has LogicalResult return type

189 ↗

(On Diff #506545)

typo

191 ↗

(On Diff #506545)

do you mean the caller?

241 ↗

(On Diff #506545)

I guess this is a partial conversion? In that case let's call it applyPartialOneToNConversion to be consistent with applyPartialConversion.

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

24 ↗

(On Diff #506545)

Wrap all conversion patterns in an anonymous namespace.

45 ↗

(On Diff #506545)

Is this needed?

mlir/lib/Transforms/Utils/OneToNTypeConversion.cpp

105–106 ↗

(On Diff #506545)

Attributes should not be leaked across pass boundaries. Does the resulting IR have such attributes? Can they be removed at the end of the dialect conversion?

Could this be done without attributes, e.g., storing the cast operations in a SmallVector in the type converter etc.?

131 ↗

(On Diff #506545)

casts

[ingomueller-net]

Thanks a lot for the thorough feedback, @springerm! Will push an updated revision in one second.

mlir/include/mlir/Dialect/Func/Transforms/OneToNFuncConversions.h

20 ↗

(On Diff #506545)

Good catch! Fixed here and in all other places I found I had them missing.

mlir/include/mlir/Transforms/OneToNTypeConversion.h

12 ↗

(On Diff #506545)

Yeah, that needs explanation. Fixed!

42 ↗

(On Diff #506545)

Yep! Added!

55 ↗

(On Diff #506545)

There can be many and what happens was eluded to with "in LIFO order". In the last revision, I elaborate more on what that means.

69 ↗

(On Diff #506545)

Good point! I have asked myself what the best practice is here for a while... turns out the developer guide suggests to not specify a size if you don't have a good argument for a particular value.

187 ↗

(On Diff #506545)

Excellent catch! The comment was out of date: I had implemented the conversion back to the original types through a return value originally but found a more elegant way through sub-classing PatternRewriter and adding an overload there that does that. The newest revision has an updated (and shorter) comment.

191 ↗

(On Diff #506545)

(removed in latest revision)

241 ↗

(On Diff #506545)

Yep, good suggestion.

I also rewrote the documentation for this function to explain in a more self-contained way what the function does (and why it is called "partial").

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

24 ↗

(On Diff #506545)

Thanks for the hint! I wasn't aware of the issue for classes, but I guess it makes sense...

45 ↗

(On Diff #506545)

Nope :) Fixed!

mlir/lib/Transforms/Utils/OneToNTypeConversion.cpp

105–106 ↗

(On Diff #506545)

I am pretty sure they can't: applyPartialOneToNConversion walks over all UnrealizedConversionCasts and replaces those with the attribute named like castKindAttrName with user materializations. All those casts that are inserted with such an attributed are thus replaced before the end of the pass.

In an earlier version, I had collected all cast ops before doing any changes but because these changes may remove some of the original cast ops, I'd have dangling pointers.

[ingomueller-net]

Address issues raised by @springerm. Thanks a lot for the thorough feedback!

[ingomueller-net]

Rebasing to latest main.

[ingomueller-net]

(Rebasing...)

[ingomueller-net]

Adding build dependencies for Bazel builds to overlay.

[ingomueller-net]

(Trying to make Phabricator do what I want...)

[mehdi_amini]

Why the revert? (please mention the revert reason in the commit message when reverting).

[ingomueller-net]

Thanks for the question and the hint. This is my first big commit and first revert :S

The Bazel build broke because I added new dependencies in CMake but not in the Bazel overlay (or whatever it's called exactly). The tests of the revision are now running (after they were stuck due to some CI problems for some time) but should finish any time. Then I'll land again.

[mehdi_amini]

Bazel is not a supported part of the project: it can't be a cause for revert as far as I am concerned.

[ingomueller-net]

I followed a suggestion from folks at Google who are responsible for the tests that failed there.

What should I do now?

[ftynse]

It's okay to reland.

[ingomueller-net]

(Rebasing as Windows build was broken due to unrelated problem.)

[mehdi_amini]

In D144469#4224367, @ingomueller-net wrote:

I followed a suggestion from folks at Google who are responsible for the tests that failed there.

Yes I figured: this wasn't good advice: downstream problems are to be handled downstream (even if it means reverting a commit downstream as needed).

What should I do now?

You can re-land as Alex mentioned, my comment was forward looking and FYI.

[ingomueller-net]

In D144469#4224625, @mehdi_amini wrote:

Yes I figured: this wasn't good advice: downstream problems are to be handled downstream (even if it means reverting a commit downstream as needed).

OK, I think I understand the policy now and follow it in the future. Thanks!

You can re-land as Alex mentioned, my comment was forward looking and FYI.

OK, thanks! Done :)

mlir/test/Transforms/decompose-call-graph-types.mlir

 // RUN: mlir-opt %s -split-input-file -test-decompose-call-graph-types | FileCheck %s
 
+// RUN: mlir-opt %s -split-input-file \
+// RUN:   -test-one-to-n-type-conversion="convert-func-ops" \
+// RUN: | FileCheck %s --check-prefix=CHECK-12N
+
 // Test case: Most basic case of a 1:N decomposition, an identity function.
 
 // CHECK-LABEL:   func @identity(
 // CHECK-SAME:                   %[[ARG0:.*]]: i1,
 // CHECK-SAME:                   %[[ARG1:.*]]: i32) -> (i1, i32) {
 // CHECK:           %[[ARG_MATERIALIZED:.*]] = "test.make_tuple"(%[[ARG0]], %[[ARG1]]) : (i1, i32) -> tuple<i1, i32>
 // CHECK:           %[[RET0:.*]] = "test.get_tuple_element"(%[[ARG_MATERIALIZED]]) {index = 0 : i32} : (tuple<i1, i32>) -> i1
 // CHECK:           %[[RET1:.*]] = "test.get_tuple_element"(%[[ARG_MATERIALIZED]]) {index = 1 : i32} : (tuple<i1, i32>) -> i32
 // CHECK:           return %[[RET0]], %[[RET1]] : i1, i32
+// CHECK-12N-LABEL:   func @identity(
+// CHECK-12N-SAME:                   %[[ARG0:.*]]: i1,
+// CHECK-12N-SAME:                   %[[ARG1:.*]]: i32) -> (i1, i32) {
+// CHECK-12N:           return %[[ARG0]], %[[ARG1]] : i1, i32
 func.func @identity(%arg0: tuple<i1, i32>) -> tuple<i1, i32> {
   return %arg0 : tuple<i1, i32>
 }
 
 // -----
 
 // Test case: Ensure no materializations in the case of 1:1 decomposition.
 
 // CHECK-LABEL:   func @identity_1_to_1_no_materializations(
 // CHECK-SAME:                                              %[[ARG0:.*]]: i1) -> i1 {
 // CHECK:           return %[[ARG0]] : i1
+// CHECK-12N-LABEL:   func @identity_1_to_1_no_materializations(
+// CHECK-12N-SAME:                                              %[[ARG0:.*]]: i1) -> i1 {
+// CHECK-12N:           return %[[ARG0]] : i1
 func.func @identity_1_to_1_no_materializations(%arg0: tuple<i1>) -> tuple<i1> {
   return %arg0 : tuple<i1>
 }
 
 // -----
 
 // Test case: Type that needs to be recursively decomposed.
 
 // CHECK-LABEL:   func @recursive_decomposition(
 // CHECK-SAME:                                   %[[ARG0:.*]]: i1) -> i1 {
 // CHECK:           return %[[ARG0]] : i1
+// CHECK-12N-LABEL:   func @recursive_decomposition(
+// CHECK-12N-SAME:                                   %[[ARG0:.*]]: i1) -> i1 {
+// CHECK-12N:           return %[[ARG0]] : i1
 func.func @recursive_decomposition(%arg0: tuple<tuple<tuple<i1>>>) -> tuple<tuple<tuple<i1>>> {
   return %arg0 : tuple<tuple<tuple<i1>>>
 }
 
 // -----
 
 // Test case: Type that needs to be recursively decomposed at different recursion depths.
 
 // CHECK-LABEL:   func @mixed_recursive_decomposition(
 // CHECK-SAME:                 %[[ARG0:.*]]: i1,
 // CHECK-SAME:                 %[[ARG1:.*]]: i2) -> (i1, i2) {
 // CHECK:           %[[V0:.*]] = "test.make_tuple"() : () -> tuple<>
 // CHECK:           %[[V1:.*]] = "test.make_tuple"(%[[ARG0]]) : (i1) -> tuple<i1>
 // CHECK:           %[[V2:.*]] = "test.make_tuple"(%[[ARG1]]) : (i2) -> tuple<i2>
 // CHECK:           %[[V3:.*]] = "test.make_tuple"(%[[V2]]) : (tuple<i2>) -> tuple<tuple<i2>>
 // CHECK:           %[[V4:.*]] = "test.make_tuple"(%[[V0]], %[[V1]], %[[V3]]) : (tuple<>, tuple<i1>, tuple<tuple<i2>>) -> tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>
 // CHECK:           %[[V5:.*]] = "test.get_tuple_element"(%[[V4]]) {index = 0 : i32} : (tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>) -> tuple<>
 // CHECK:           %[[V6:.*]] = "test.get_tuple_element"(%[[V4]]) {index = 1 : i32} : (tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>) -> tuple<i1>
 // CHECK:           %[[V7:.*]] = "test.get_tuple_element"(%[[V6]]) {index = 0 : i32} : (tuple<i1>) -> i1
 // CHECK:           %[[V8:.*]] = "test.get_tuple_element"(%[[V4]]) {index = 2 : i32} : (tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>) -> tuple<tuple<i2>>
 // CHECK:           %[[V9:.*]] = "test.get_tuple_element"(%[[V8]]) {index = 0 : i32} : (tuple<tuple<i2>>) -> tuple<i2>
 // CHECK:           %[[V10:.*]] = "test.get_tuple_element"(%[[V9]]) {index = 0 : i32} : (tuple<i2>) -> i2
 // CHECK:           return %[[V7]], %[[V10]] : i1, i2
+// CHECK-12N-LABEL:   func @mixed_recursive_decomposition(
+// CHECK-12N-SAME:                 %[[ARG0:.*]]: i1,
+// CHECK-12N-SAME:                 %[[ARG1:.*]]: i2) -> (i1, i2) {
+// CHECK-12N:           return %[[ARG0]], %[[ARG1]] : i1, i2
 func.func @mixed_recursive_decomposition(%arg0: tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>) -> tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>> {
   return %arg0 : tuple<tuple<>, tuple<i1>, tuple<tuple<i2>>>
 }
 
 // -----
 
 // Test case: Check decomposition of calls.
 
 // CHECK-LABEL:   func private @callee(i1, i32) -> (i1, i32)
+// CHECK-12N-LABEL:   func private @callee(i1, i32) -> (i1, i32)
 func.func private @callee(tuple<i1, i32>) -> tuple<i1, i32>
 
 // CHECK-LABEL:   func @caller(
 // CHECK-SAME:                 %[[ARG0:.*]]: i1,
 // CHECK-SAME:                 %[[ARG1:.*]]: i32) -> (i1, i32) {
 // CHECK:           %[[ARG_MATERIALIZED:.*]] = "test.make_tuple"(%[[ARG0]], %[[ARG1]]) : (i1, i32) -> tuple<i1, i32>
 // CHECK:           %[[CALL_ARG0:.*]] = "test.get_tuple_element"(%[[ARG_MATERIALIZED]]) {index = 0 : i32} : (tuple<i1, i32>) -> i1
 // CHECK:           %[[CALL_ARG1:.*]] = "test.get_tuple_element"(%[[ARG_MATERIALIZED]]) {index = 1 : i32} : (tuple<i1, i32>) -> i32
 // CHECK:           %[[DECOMPOSED:.*]]:2 = call @callee(%[[CALL_ARG0]], %[[CALL_ARG1]]) : (i1, i32) -> (i1, i32)
 // CHECK:           %[[CALL_RESULT_RECOMPOSED:.*]] = "test.make_tuple"(%[[DECOMPOSED]]#0, %[[DECOMPOSED]]#1) : (i1, i32) -> tuple<i1, i32>
 // CHECK:           %[[RET0:.*]] = "test.get_tuple_element"(%[[CALL_RESULT_RECOMPOSED]]) {index = 0 : i32} : (tuple<i1, i32>) -> i1
 // CHECK:           %[[RET1:.*]] = "test.get_tuple_element"(%[[CALL_RESULT_RECOMPOSED]]) {index = 1 : i32} : (tuple<i1, i32>) -> i32
 // CHECK:           return %[[RET0]], %[[RET1]] : i1, i32
+// CHECK-12N-LABEL:   func @caller(
+// CHECK-12N-SAME:                 %[[ARG0:.*]]: i1,
+// CHECK-12N-SAME:                 %[[ARG1:.*]]: i32) -> (i1, i32) {
+// CHECK-12N:           %[[V0:.*]]:2 = call @callee(%[[ARG0]], %[[ARG1]]) : (i1, i32) -> (i1, i32)
+// CHECK-12N:           return %[[V0]]#0, %[[V0]]#1 : i1, i32
 func.func @caller(%arg0: tuple<i1, i32>) -> tuple<i1, i32> {
   %0 = call @callee(%arg0) : (tuple<i1, i32>) -> tuple<i1, i32>
   return %0 : tuple<i1, i32>
 }
 
 // -----
 
 // Test case: Type that decomposes to nothing (that is, a 1:0 decomposition).
 
 // CHECK-LABEL:   func private @callee()
+// CHECK-12N-LABEL:   func private @callee()
 func.func private @callee(tuple<>) -> tuple<>
+
+// CHECK-12N-LABEL:   func @caller() {
+// CHECK-12N:           call @callee() : () -> ()
+// CHECK-12N:           return
 // CHECK-LABEL:   func @caller() {
 // CHECK:           call @callee() : () -> ()
 // CHECK:           return
 func.func @caller(%arg0: tuple<>) -> tuple<> {
   %0 = call @callee(%arg0) : (tuple<>) -> (tuple<>)
   return %0 : tuple<>
 }
 
 // -----
 
 // Test case: Ensure decompositions are inserted properly around results of
 // unconverted ops.
 
 // CHECK-LABEL:   func @unconverted_op_result() -> (i1, i32) {
 // CHECK:           %[[UNCONVERTED_VALUE:.*]] = "test.source"() : () -> tuple<i1, i32>
 // CHECK:           %[[RET0:.*]] = "test.get_tuple_element"(%[[UNCONVERTED_VALUE]]) {index = 0 : i32} : (tuple<i1, i32>) -> i1
 // CHECK:           %[[RET1:.*]] = "test.get_tuple_element"(%[[UNCONVERTED_VALUE]]) {index = 1 : i32} : (tuple<i1, i32>) -> i32
 // CHECK:           return %[[RET0]], %[[RET1]] : i1, i32
+// CHECK-12N-LABEL:   func @unconverted_op_result() -> (i1, i32) {
+// CHECK-12N:           %[[UNCONVERTED_VALUE:.*]] = "test.source"() : () -> tuple<i1, i32>
+// CHECK-12N:           %[[RET0:.*]] = "test.get_tuple_element"(%[[UNCONVERTED_VALUE]]) {index = 0 : i32} : (tuple<i1, i32>) -> i1
+// CHECK-12N:           %[[RET1:.*]] = "test.get_tuple_element"(%[[UNCONVERTED_VALUE]]) {index = 1 : i32} : (tuple<i1, i32>) -> i32
+// CHECK-12N:           return %[[RET0]], %[[RET1]] : i1, i32
 func.func @unconverted_op_result() -> tuple<i1, i32> {
   %0 = "test.source"() : () -> (tuple<i1, i32>)
   return %0 : tuple<i1, i32>
 }
 
 // -----
 
 // Test case: Ensure decompositions are inserted properly around results of
 // unconverted ops in the case of different nesting levels.
 
 // CHECK-LABEL:   func @nested_unconverted_op_result(
 // CHECK-SAME:                 %[[ARG0:.*]]: i1,
 // CHECK-SAME:                 %[[ARG1:.*]]: i32) -> (i1, i32) {
 // CHECK:           %[[V0:.*]] = "test.make_tuple"(%[[ARG1]]) : (i32) -> tuple<i32>
 // CHECK:           %[[V1:.*]] = "test.make_tuple"(%[[ARG0]], %[[V0]]) : (i1, tuple<i32>) -> tuple<i1, tuple<i32>>
 // CHECK:           %[[V2:.*]] = "test.op"(%[[V1]]) : (tuple<i1, tuple<i32>>) -> tuple<i1, tuple<i32>>
 // CHECK:           %[[V3:.*]] = "test.get_tuple_element"(%[[V2]]) {index = 0 : i32} : (tuple<i1, tuple<i32>>) -> i1
 // CHECK:           %[[V4:.*]] = "test.get_tuple_element"(%[[V2]]) {index = 1 : i32} : (tuple<i1, tuple<i32>>) -> tuple<i32>
 // CHECK:           %[[V5:.*]] = "test.get_tuple_element"(%[[V4]]) {index = 0 : i32} : (tuple<i32>) -> i32
 // CHECK:           return %[[V3]], %[[V5]] : i1, i32
+// CHECK-12N-LABEL:   func @nested_unconverted_op_result(
+// CHECK-12N-SAME:                 %[[ARG0:.*]]: i1,
+// CHECK-12N-SAME:                 %[[ARG1:.*]]: i32) -> (i1, i32) {
+// CHECK-12N:           %[[V0:.*]] = "test.make_tuple"(%[[ARG1]]) : (i32) -> tuple<i32>
+// CHECK-12N:           %[[V1:.*]] = "test.make_tuple"(%[[ARG0]], %[[V0]]) : (i1, tuple<i32>) -> tuple<i1, tuple<i32>>
+// CHECK-12N:           %[[V2:.*]] = "test.op"(%[[V1]]) : (tuple<i1, tuple<i32>>) -> tuple<i1, tuple<i32>>
+// CHECK-12N:           %[[V3:.*]] = "test.get_tuple_element"(%[[V2]]) {index = 0 : i32} : (tuple<i1, tuple<i32>>) -> i1
+// CHECK-12N:           %[[V4:.*]] = "test.get_tuple_element"(%[[V2]]) {index = 1 : i32} : (tuple<i1, tuple<i32>>) -> tuple<i32>
+// CHECK-12N:           %[[V5:.*]] = "test.get_tuple_element"(%[[V4]]) {index = 0 : i32} : (tuple<i32>) -> i32
+// CHECK-12N:           return %[[V3]], %[[V5]] : i1, i32
 func.func @nested_unconverted_op_result(%arg: tuple<i1, tuple<i32>>) -> tuple<i1, tuple<i32>> {
   %0 = "test.op"(%arg) : (tuple<i1, tuple<i32>>) -> (tuple<i1, tuple<i32>>)
   return %0 : tuple<i1, tuple<i32>>
 }
 
 // -----
 
 // Test case: Check mixed decomposed and non-decomposed args.
 // This makes sure to test the cases if 1:0, 1:1, and 1:N decompositions.
 
 // CHECK-LABEL:   func private @callee(i1, i2, i3, i4, i5, i6) -> (i1, i2, i3, i4, i5, i6)
+// CHECK-12N-LABEL:   func private @callee(i1, i2, i3, i4, i5, i6) -> (i1, i2, i3, i4, i5, i6)
 func.func private @callee(tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6) -> (tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6)
 
 // CHECK-LABEL:   func @caller(
 // CHECK-SAME:                 %[[I1:.*]]: i1,
 // CHECK-SAME:                 %[[I2:.*]]: i2,
 // CHECK-SAME:                 %[[I3:.*]]: i3,
 // CHECK-SAME:                 %[[I4:.*]]: i4,
 // CHECK-SAME:                 %[[I5:.*]]: i5,
 // CHECK-SAME:                 %[[I6:.*]]: i6) -> (i1, i2, i3, i4, i5, i6) {
 // CHECK:           %[[ARG_TUPLE:.*]] = "test.make_tuple"(%[[I4]], %[[I5]]) : (i4, i5) -> tuple<i4, i5>
 // CHECK:           %[[ARG_TUPLE_0:.*]] = "test.get_tuple_element"(%[[ARG_TUPLE]]) {index = 0 : i32} : (tuple<i4, i5>) -> i4
 // CHECK:           %[[ARG_TUPLE_1:.*]] = "test.get_tuple_element"(%[[ARG_TUPLE]]) {index = 1 : i32} : (tuple<i4, i5>) -> i5
 // CHECK:           %[[CALL:.*]]:6 = call @callee(%[[I1]], %[[I2]], %[[I3]], %[[ARG_TUPLE_0]], %[[ARG_TUPLE_1]], %[[I6]]) : (i1, i2, i3, i4, i5, i6) -> (i1, i2, i3, i4, i5, i6)
 // CHECK:           %[[RET_TUPLE:.*]] = "test.make_tuple"(%[[CALL]]#3, %[[CALL]]#4) : (i4, i5) -> tuple<i4, i5>
 // CHECK:           %[[RET_TUPLE_0:.*]] = "test.get_tuple_element"(%[[RET_TUPLE]]) {index = 0 : i32} : (tuple<i4, i5>) -> i4
 // CHECK:           %[[RET_TUPLE_1:.*]] = "test.get_tuple_element"(%[[RET_TUPLE]]) {index = 1 : i32} : (tuple<i4, i5>) -> i5
 // CHECK:           return %[[CALL]]#0, %[[CALL]]#1, %[[CALL]]#2, %[[RET_TUPLE_0]], %[[RET_TUPLE_1]], %[[CALL]]#5 : i1, i2, i3, i4, i5, i6
+// CHECK-12N-LABEL:   func @caller(
+// CHECK-12N-SAME:                 %[[I1:.*]]: i1,
+// CHECK-12N-SAME:                 %[[I2:.*]]: i2,
+// CHECK-12N-SAME:                 %[[I3:.*]]: i3,
+// CHECK-12N-SAME:                 %[[I4:.*]]: i4,
+// CHECK-12N-SAME:                 %[[I5:.*]]: i5,
+// CHECK-12N-SAME:                 %[[I6:.*]]: i6) -> (i1, i2, i3, i4, i5, i6) {
+// CHECK-12N:           %[[CALL:.*]]:6 = call @callee(%[[I1]], %[[I2]], %[[I3]], %[[I4]], %[[I5]], %[[I6]]) : (i1, i2, i3, i4, i5, i6) -> (i1, i2, i3, i4, i5, i6)
+// CHECK-12N:           return %[[CALL]]#0, %[[CALL]]#1, %[[CALL]]#2, %[[CALL]]#3, %[[CALL]]#4, %[[CALL]]#5 : i1, i2, i3, i4, i5, i6
 func.func @caller(%arg0: tuple<>, %arg1: i1, %arg2: tuple<i2>, %arg3: i3, %arg4: tuple<i4, i5>, %arg5: i6) -> (tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6) {
   %0, %1, %2, %3, %4, %5 = call @callee(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6) -> (tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6)
   return %0, %1, %2, %3, %4, %5 : tuple<>, i1, tuple<i2>, i3, tuple<i4, i5>, i6
 }

mlir/test/lib/Conversion/CMakeLists.txt

 add_subdirectory(FuncToLLVM)
+add_subdirectory(OneToNTypeConversion)

mlir/test/lib/Conversion/OneToNTypeConversion/CMakeLists.txt

+add_mlir_library(MLIRTestOneToNTypeConversionPass
+  OneToNTypeConversion.cpp
+  OneToNTypeConversionFunc.cpp
+  TestOneToNTypeConversionPass.cpp
+
+  EXCLUDE_FROM_LIBMLIR
+
+  LINK_LIBS PUBLIC
+  MLIRFuncDialect
+  MLIRIR
+  MLIRTestDialect
+  MLIRTransformUtils
+ )
+
+target_include_directories(MLIRTestOneToNTypeConversionPass
+  PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
+  ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
+  )

mlir/test/lib/Conversion/OneToNTypeConversion/OneToNTypeConversion.h

+//===-- OneToNTypeConversion.h - Utils for 1:N type conversion --*- C++ -*-===//
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides utils for implementing (poor-man's) dialect conversion
+// passes with 1:N type conversions.
+//
+// The main function first applies a set of RewritePatterns, which produce
+// unrealized casts to convert the operands and results from and to the source
+// types, and then replaces all newly added unrealized casts by user-provided
+// materializations. For this to work, the main function requires a special
+// TypeConverter and special RewritePatterns, respectively deriving from the
+// provided classes, which extend their respective base classes for 1:N type
+// converions.
+//
+// Note that this is much more simple-minded than the "real" dialect conversion,
+// which checks for legality before applying patterns and does probably many
+// other additional things. Ideally, some of the extensions here could be
+// integrated there.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSION_H
+#define TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSION_H
+
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace mlir {
+
+/// Extends `TypeConverter` with 1:N target materializations. Such
+/// materializations have to provide the "reverse" of 1:N type conversions,
+/// i.e., they need to materialize N values with target types into one value
+/// with a source type (which isn't possible in the base class currently).
+class OneToNTypeConverter : public TypeConverter {
+public:
+  using OneToNMaterializationCallbackFn =
+      std::function<std::optional<SmallVector<Value>>(OpBuilder &, TypeRange,
+                                                      Value, Location)>;
+
+  /// Creates the mapping of the given range of original types to target types
+  /// of the conversion and stores that mapping in the given (signature)
+  /// conversion. This function simply calls TypeConverter::convertSignatureArgs
+  /// and exists here with a different name to reflect the broader semantic.
+  LogicalResult computeTypeMapping(TypeRange types,
+                                   SignatureConversion &result) {
+    return convertSignatureArgs(types, result);
+  }
+
+  /// Applies one of the user-provided 1:N target materializations (in LIFO
+  /// order).
+  std::optional<SmallVector<Value>>
+  materializeTargetConversion(OpBuilder &builder, Location loc,
+                              TypeRange resultTypes, Value input) const;
+
+  /// Adds a 1:N target materialization to the converter. Such materializations
+  /// build IR that converts N values with target types into 1 value of the
+  /// source type.
+  void addTargetMaterialization(OneToNMaterializationCallbackFn &&callback) {
+    oneToNTargetMaterializations.emplace_back(std::move(callback));
+  }
+
+private:
+  SmallVector<OneToNMaterializationCallbackFn, 2> oneToNTargetMaterializations;
+};
+
+/// Stores a 1:N mapping of types and provides several useful accessors. This
+/// class extends SignatureConversion, which already supports 1:N type mappings
+/// but lacks some accessors into the mapping as well as access to the original
+/// types.
+class OneToNTypeMapping : public TypeConverter::SignatureConversion {
+public:
+  OneToNTypeMapping(TypeRange originalTypes)
+      : TypeConverter::SignatureConversion(originalTypes.size()),
+        originalTypes(originalTypes) {}
+
+  using TypeConverter::SignatureConversion::getConvertedTypes;
+
+  /// Returns the list of types that corresponds to the original type at the
+  /// given index.
+  TypeRange getConvertedTypes(unsigned originalTypeNo) const;
+
+  /// Returns the list of original types.
+  TypeRange getOriginalTypes() const { return originalTypes; }
+
+  /// Returns the slice of converted values that corresponds the original value
+  /// at the given index.
+  ValueRange getConvertedValues(ValueRange convertedValues,
+                                unsigned originalValueNo) const;
+
+  /// Fills the given result vector with as many copies of the location of the
+  /// original value as the number of values it is converted to.
+  void convertLocation(Value originalValue, unsigned originalValueNo,
+                       llvm::SmallVectorImpl<Location> &result) const;
+
+  /// Fills the given result vector with as many copies of the lociation of each
+  /// original value as the number of values they are respectively converted to.
+  void convertLocations(ValueRange originalValues,
+                        llvm::SmallVectorImpl<Location> &result) const;
+
+  /// Returns true iff at least one type conversion maps an input type to a type
+  /// that is different from itself.
+  bool hasNonIdentityConversion() const;
+
+private:
+  llvm::SmallVector<Type> originalTypes;
+};
+
+/// Extends the basic RewritePattern with a type converter member and some
+/// accessors to it. This is useful for patterns that are not ConversionPatterns
+/// but still require access to a type converter.
+class RewritePatternWithConverter : public mlir::RewritePattern {
+public:
+  /// Construct a conversion pattern with the given converter, and forward the
+  /// remaining arguments to RewritePattern.
+  template <typename... Args>
+  RewritePatternWithConverter(TypeConverter &typeConverter, Args &&...args)
+      : RewritePattern(std::forward<Args>(args)...),
+        typeConverter(&typeConverter) {}
+
+  /// Return the type converter held by this pattern, or nullptr if the pattern
+  /// does not require type conversion.
+  TypeConverter *getTypeConverter() const { return typeConverter; }
+
+  template <typename ConverterTy>
+  std::enable_if_t<std::is_base_of<TypeConverter, ConverterTy>::value,
+                   ConverterTy *>
+  getTypeConverter() const {
+    return static_cast<ConverterTy *>(typeConverter);
+  }
+
+protected:
+  /// A type converter for use by this pattern.
+  TypeConverter *const typeConverter;
+};
+
+/// Specialization of PatternRewriter that OneToNConversionPatterns use. The
+/// class provides additional rewrite methods that are specific to 1:N type
+/// conversions.
+class OneToNPatternRewriter : public PatternRewriter {
+public:
+  OneToNPatternRewriter(MLIRContext *context) : PatternRewriter(context) {}
+
+  /// Replaces the results of the operation with the specified list of values
+  /// mapped back to the original types as specified in the provided type
+  /// mapping. That type mapping must match the replaced op (i.e., the original
+  /// types must be the same as the result types of the op) and the new values
+  /// (i.e., the converted types must be the same as the types of the new
+  /// values).
+  void replaceOp(Operation *op, ValueRange newValues,
+                 const OneToNTypeMapping &resultMapping);
+  using PatternRewriter::replaceOp;
+
+  /// Applies the given argument conversion to the given block. This consists of
+  /// replacing each original argument with N arguments as specified in the
+  /// argument conversion and inserting unrealized casts from the converted
+  /// values to the original types, which are then used in lieu of the original
+  /// ones. (Eventually, applyOneToNConversion replaces these casts with a
+  /// user-provided argument materialization if necessary.) This is similar to
+  /// ArgConverter::applySignatureConversion but (1) handles 1:N type conversion
+  /// properly and probably (2) doesn't handle many other edge cases.
+  Block *applySignatureConversion(Block *block,
+                                  OneToNTypeMapping &argumentConversion);
+};
+
+/// Base class for patterns with 1:N type conversions. Derived classes have to
+/// overwrite the `matchAndRewrite`overlaod that provides additional information
+/// for 1:N type conversions.
+class OneToNConversionPattern : public RewritePatternWithConverter {
+public:
+  using RewritePatternWithConverter::RewritePatternWithConverter;
+
+  /// This function has to be implemented by base classes and is called from the
+  /// usual overloads. Like in normal DialectConversion, the function is
+  /// provided with the converted operands (which thus have target types). Since
+  /// 1:N conversion are supported, there is usually no 1:1 relationship between
+  /// the original and the converted operands. Instead, the provided
+  /// `operandMapping` can be used to access the converted operands that
+  /// correspond to a particular original operand. Similarly, `resultMapping`
+  /// is provided to help with assembling the result values (which may have 1:N
+  /// correspondences as well). The function is expted to return the converted
+  /// result values if the conversion succeeds and failure otherwise (in which
+  /// case any modifications of the IR have to be rolled back first). The
+  /// correspondance of original and converted result values needs to correspond
+  /// to `resultMapping`. For both the converted operands and results, the
+  /// calling overload inserts appropriate unrealized casts that produce and
+  /// consume them, and replaces the uses of the results with the results of the
+  /// casts. If the returned result values are the same as those of the original
+  /// op, an in-place update is assumed and the result values are left as is.
+  virtual LogicalResult
+  matchAndRewrite(Operation *op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const = 0;
+
+  LogicalResult matchAndRewrite(Operation *op,
+                                PatternRewriter &rewriter) const final;
+};
+
+/// This class is a wrapper around OneToNConversionPattern for matching against
+/// instances of a particular op class.
+template <typename SourceOp>
+class OneToNOpConversionPattern : public OneToNConversionPattern {
+public:
+  OneToNOpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
+                            PatternBenefit benefit = 1,
+                            ArrayRef<StringRef> generatedNames = {})
+      : OneToNConversionPattern(typeConverter, SourceOp::getOperationName(),
+                                benefit, context, generatedNames) {}
+
+  using OneToNConversionPattern::matchAndRewrite;
+
+  /// Overload that derived classes have to override for their op type.
+  virtual LogicalResult
+  matchAndRewrite(SourceOp op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const = 0;
+
+  LogicalResult
+  matchAndRewrite(Operation *op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const final {
+    return matchAndRewrite(cast<SourceOp>(op), rewriter, operandMapping,
+                           resultMapping, convertedOperands);
+  }
+};
+
+/// Main function that 1:N conversion passes should call. The patterns are
+/// expected to insert unrealized casts to maintain the types of operands and
+/// results, which is done automatically if the derive from
+/// OneToNConversionPattern. The function replaces those that do not fold away
+/// until the end of pattern application with user-provided materializations
+/// from the type converter, so those have to be provided if conversions from
+/// source to target types are expected to remain.
+LogicalResult applyOneToNConversion(Operation *op,
+                                    OneToNTypeConverter &typeConverter,
+                                    const FrozenRewritePatternSet &patterns);
+
+} // namespace mlir
+
+#endif // TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSION_H

mlir/test/lib/Conversion/OneToNTypeConversion/OneToNTypeConversion.cpp

+//===-- OneToNTypeConversion.cpp - Utils for 1:N type conversion-*- C++ -*-===//
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "OneToNTypeConversion.h"
+
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "llvm/ADT/SmallSet.h"
+
+using namespace llvm;
+using namespace mlir;
+
+std::optional<SmallVector<Value>>
+OneToNTypeConverter::materializeTargetConversion(OpBuilder &builder,
+                                                 Location loc,
+                                                 TypeRange resultTypes,
+                                                 Value input) const {
+  for (const OneToNMaterializationCallbackFn &fn :
+       llvm::reverse(oneToNTargetMaterializations)) {
+    if (std::optional<SmallVector<Value>> result =
+            fn(builder, resultTypes, input, loc))
+      return *result;
+  }
+  return {};
+}
+
+TypeRange OneToNTypeMapping::getConvertedTypes(unsigned originalTypeNo) const {
+  TypeRange convertedTypes = getConvertedTypes();
+  if (auto mapping = getInputMapping(originalTypeNo))
+    return convertedTypes.slice(mapping->inputNo, mapping->size);
+  return {};
+}
+
+ValueRange
+OneToNTypeMapping::getConvertedValues(ValueRange convertedValues,
+                                      unsigned originalValueNo) const {
+  if (auto mapping = getInputMapping(originalValueNo))
+    return convertedValues.slice(mapping->inputNo, mapping->size);
+  return {};
+}
+
+void OneToNTypeMapping::convertLocation(
+    Value originalValue, unsigned originalValueNo,
+    llvm::SmallVectorImpl<Location> &result) const {
+  if (auto mapping = getInputMapping(originalValueNo))
+    result.append(mapping->size, originalValue.getLoc());
+}
+
+void OneToNTypeMapping::convertLocations(
+    ValueRange originalValues, llvm::SmallVectorImpl<Location> &result) const {
+  assert(originalValues.size() == getOriginalTypes().size());
+  for (auto &[i, value] : llvm::enumerate(originalValues))
+    convertLocation(value, i, result);
+}
+
+static bool isIdentityConversion(Type originalType, TypeRange convertedTypes) {
+  return convertedTypes.size() == 1 && convertedTypes[0] == originalType;
+}
+
+bool OneToNTypeMapping::hasNonIdentityConversion() const {
+  // XXX: I think that the original types and the converted types are the same
+  //      iff there was no non-identity type conversion. If that is true, the
+  //      patterns could actually test whether there is anything useful to do
+  //      without having access to the signature conversion.
+  for (auto [i, originalType] : llvm::enumerate(originalTypes)) {
+    TypeRange types = getConvertedTypes(i);
+    if (!isIdentityConversion(originalType, types)) {
+      assert(TypeRange(originalTypes) != getConvertedTypes());
+      return true;
+    }
+  }
+  assert(TypeRange(originalTypes) == getConvertedTypes());
+  return false;
+}
+
+enum class CastKind {
+  // Casts block arguments in the target type back to the source type. (If
+  // necessary, this cast becomes an argument materialization.)
+  Argument,
+
+  // Casts other values in the target type back to the source type. (If
+  // necessary, this cast becomes a source materialization.)
+  Source,
+
+  // Casts values in the source type to the target type. (If necessary, this
+  // cast becomes a target materialization.)
+  Target
+};
+
+/// Mapping of enum values to string values.
+static const std::unordered_map<CastKind, StringRef> castKindNames = {
+    {CastKind::Argument, "argument"},
+    {CastKind::Source, "source"},
+    {CastKind::Target, "target"}};
+
+/// Attribute name that is used to annotate inserted unrealized casts with their
+/// kind (source, argument, or target).
+static const char *const castKindAttrName =
+    "__one-to-n-type-conversion_cast-kind__";
+
+/// Builds an UnrealizedConversionCastOp from the given inputs to the given
+/// result types. Returns the result values of the cast.
+static ValueRange buildUnrealizedCast(OpBuilder &builder, TypeRange resultTypes,
+                                      ValueRange inputs, CastKind kind) {
+  // Create cast.
+  Location loc = builder.getUnknownLoc();
+  if (!inputs.empty())
+    loc = inputs.front().getLoc();
+  auto castOp =
+      builder.create<UnrealizedConversionCastOp>(loc, resultTypes, inputs);
+
+  // Store cast kind as attribute.
+  auto kindAttr = StringAttr::get(builder.getContext(), castKindNames.at(kind));
+  castOp->setAttr(castKindAttrName, kindAttr);
+
+  return castOp->getResults();
+}
+
+/// Builds one UnrealizedConversionCastOp for each of the given original values
+/// using the respective target types given in the provided conversion mapping
+/// and returns the results of these casts. If the conversion mapping of a value
+/// maps a type to itself (i.e., is an identity conversion), then no cast is
+/// inserted and the original value is returned instead.
+/// Note that these unrealized are different from target materializations in
+/// that they are *always* inserted, even if they immediately fold away, such
+/// that patterns always see valid intermediate IR, whereas materializations are
+/// only used in the places where the unrealized casts *don't* fold away.
+static SmallVector<Value>
+buildUnrealizedForwardCasts(ValueRange originalValues,
+                            OneToNTypeMapping &conversion,
+                            RewriterBase &rewriter, CastKind kind) {
+
+  // Convert each operand one by one.
+  SmallVector<Value> convertedValues;
+  convertedValues.reserve(conversion.getConvertedTypes().size());
+  for (auto [idx, originalValue] : llvm::enumerate(originalValues)) {
+    TypeRange convertedTypes = conversion.getConvertedTypes(idx);
+
+    // Identity conversion: keep operand as is.
+    if (isIdentityConversion(originalValue.getType(), convertedTypes)) {
+      convertedValues.push_back(originalValue);
+      continue;
+    }
+
+    // Non-identity conversion: materialize target types.
+    ValueRange castResult =
+        buildUnrealizedCast(rewriter, convertedTypes, originalValue, kind);
+    convertedValues.append(castResult.begin(), castResult.end());
+  }
+
+  return convertedValues;
+}
+
+/// Builds one UnrealizedConversionCastOp for each sequence of the given
+/// original values to one value of the type they originated from, i.e., a
+/// "reverse" conversion from N converted values back to one value of the
+/// original type, using the given (forward) type conversion. If a given value
+/// was mapped to a value of the same type (i.e., the conversion in the mapping
+/// is an identity conversion), then the "converted" value is returned without
+/// cast.
+/// Note that these unrealized are different from source materializations in
+/// that they are *always* inserted, even if they immediately fold away, such
+/// that patterns always see valid intermediate IR, whereas materializations are
+/// only used in the places where the unrealized casts *don't* fold away.
+static SmallVector<Value>
+buildUnrealizedBackwardsCasts(ValueRange convertedValues,
+                              const OneToNTypeMapping &typeConversion,
+                              RewriterBase &rewriter) {
+  assert(typeConversion.getConvertedTypes() == convertedValues.getTypes());
+
+  // Create unrealized cast op for each converted result of the op.
+  SmallVector<Value> recastValues;
+  TypeRange originalTypes = typeConversion.getOriginalTypes();
+  recastValues.reserve(originalTypes.size());
+  auto convertedValueIt = convertedValues.begin();
+  for (auto [idx, originalType] : llvm::enumerate(originalTypes)) {
+    TypeRange convertedTypes = typeConversion.getConvertedTypes(idx);
+    size_t numConvertedValues = convertedTypes.size();
+    if (isIdentityConversion(originalType, convertedTypes)) {
+      // Identity conversion: take result as is.
+      recastValues.push_back(*convertedValueIt);
+    } else {
+      // Non-identity conversion: cast back to source type.
+      ValueRange recastValue = buildUnrealizedCast(
+          rewriter, originalType,
+          ValueRange{convertedValueIt, convertedValueIt + numConvertedValues},
+          CastKind::Source);
+      assert(recastValue.size() == 1);
+      recastValues.push_back(recastValue.front());
+    }
+    convertedValueIt += numConvertedValues;
+  }
+
+  return recastValues;
+}
+
+void OneToNPatternRewriter::replaceOp(Operation *op, ValueRange newValues,
+                                      const OneToNTypeMapping &resultMapping) {
+  // Create a cast back to the original types and replace the results of the
+  // original op with those.
+  assert(newValues.size() == resultMapping.getConvertedTypes().size());
+  assert(op->getResultTypes() == resultMapping.getOriginalTypes());
+  SmallVector<Value> castResults =
+      buildUnrealizedBackwardsCasts(newValues, resultMapping, *this);
+  replaceOp(op, castResults);
+}
+
+Block *OneToNPatternRewriter::applySignatureConversion(
+    Block *block, OneToNTypeMapping &argumentConversion) {
+  // Split the block at the beginning to get a new block to use for the
+  // updated signature.
+  SmallVector<Location> locs;
+  argumentConversion.convertLocations(block->getArguments(), locs);
+  Block *newBlock =
+      createBlock(block, argumentConversion.getConvertedTypes(), locs);
+  replaceAllUsesWith(block, newBlock);
+
+  // Create necessary casts in new block.
+  SmallVector<Value> castResults;
+  for (auto [i, arg] : llvm::enumerate(block->getArguments())) {
+    TypeRange convertedTypes = argumentConversion.getConvertedTypes(i);
+    ValueRange newArgs =
+        argumentConversion.getConvertedValues(newBlock->getArguments(), i);
+    if (isIdentityConversion(arg.getType(), convertedTypes)) {
+      // Identity conversion: take argument as is.
+      assert(newArgs.size() == 1);
+      castResults.push_back(newArgs.front());
+    } else {
+      // Non-identity conversion: cast the converted arguments to the original
+      // type.
+      PatternRewriter::InsertionGuard g(*this);
+      setInsertionPointToStart(newBlock);
+      ValueRange castResult = buildUnrealizedCast(*this, arg.getType(), newArgs,
+                                                  CastKind::Argument);
+      assert(castResult.size() == 1);
+      castResults.push_back(castResult.front());
+    }
+  }
+
+  // Merge old block into new block such that we only have the latter with the
+  // new signature.
+  mergeBlocks(block, newBlock, castResults);
+
+  return newBlock;
+}
+
+LogicalResult
+OneToNConversionPattern::matchAndRewrite(Operation *op,
+                                         PatternRewriter &rewriter) const {
+  auto *typeConverter = getTypeConverter<OneToNTypeConverter>();
+
+  // Construct conversion mapping for results.
+  Operation::result_type_range originalResultTypes = op->getResultTypes();
+  OneToNTypeMapping resultMapping(originalResultTypes);
+  if (failed(typeConverter->computeTypeMapping(originalResultTypes,
+                                               resultMapping)))
+    return failure();
+
+  // Construct conversion mapping for operands.
+  Operation::operand_type_range originalOperandTypes = op->getOperandTypes();
+  OneToNTypeMapping operandMapping(originalOperandTypes);
+  if (failed(typeConverter->computeTypeMapping(originalOperandTypes,
+                                               operandMapping)))
+    return failure();
+
+  // Cast operands to target types.
+  SmallVector<Value> convertedOperands = buildUnrealizedForwardCasts(
+      op->getOperands(), operandMapping, rewriter, CastKind::Target);
+
+  // Create a OneToNPatternRewriter for the pattern, which provides additional
+  // functionality.
+  // TODO(ingomueller): I guess it would be better to use only one rewriter
+  //                    throughout the whole pass, but that would require to
+  //                    drive the pattern application ourselves, which is a lot
+  //                    of additional boilerplate code. This seems to work fine,
+  //                    so I leave it like this for the time being.
+  OneToNPatternRewriter oneToNPatternRewriter(rewriter.getContext());
+  oneToNPatternRewriter.restoreInsertionPoint(rewriter.saveInsertionPoint());
+  oneToNPatternRewriter.setListener(rewriter.getListener());
+
+  // Apply actual pattern.
+  if (failed(matchAndRewrite(op, oneToNPatternRewriter, operandMapping,
+                             resultMapping, convertedOperands)))
+    return failure();
+
+  return success();
+}
+
+namespace mlir {
+
+// This function applies the provided patterns using
+// applyPatternsAndFoldGreedily and then replaces all newly inserted
+// UnrealizedConversionCastOps that haven't folded away. ("Backward" casts from
+// target to source types inserted by a OneToNConversionPattern normally fold
+// away with the "forward" casts from source to target types inserted by the
+// next pattern.) To understand which casts are "newly inserted", all casts
+// inserted by this pass are annotated with a string attribute that also
+// documents which kind of the cast (source, argument, or target).
+LogicalResult applyOneToNConversion(Operation *op,
+                                    OneToNTypeConverter &typeConverter,
+                                    const FrozenRewritePatternSet &patterns) {
+#ifndef NDEBUG
+  // Remember existing unrealized casts. This data structure is only used in
+  // asserts; building it only for that purpose may be an overkill.
+  SmallSet<UnrealizedConversionCastOp, 4> existingCasts;
+  op->walk([&](UnrealizedConversionCastOp castOp) {
+    assert(!castOp->hasAttr(castKindAttrName));
+    existingCasts.insert(castOp);
+  });
+#endif // NDEBUG
+
+  // Apply provided conversion patterns.
+  if (failed(applyPatternsAndFoldGreedily(op, patterns))) {
+    emitError(op->getLoc()) << "failed to apply conversion patterns";
+    return failure();
+  }
+
+  // Find all unrealized casts inserted by the pass that haven't folded away.
+  SmallVector<UnrealizedConversionCastOp> worklist;
+  op->walk([&](UnrealizedConversionCastOp castOp) {
+    if (castOp->hasAttr(castKindAttrName)) {
+      assert(!existingCasts.contains(castOp));
+      worklist.push_back(castOp);
+    }
+  });
+
+  // Replace new casts with user materializations.
+  IRRewriter rewriter(op->getContext());
+  for (UnrealizedConversionCastOp castOp : worklist) {
+    TypeRange resultTypes = castOp->getResultTypes();
+    ValueRange operands = castOp->getOperands();
+    StringRef castKind =
+        castOp->getAttrOfType<StringAttr>(castKindAttrName).getValue();
+    rewriter.setInsertionPoint(castOp);
+
+#ifndef NDEBUG
+    // Determine whether operands or results are already legal to test some
+    // assumptions for the different kind of materializations. These properties
+    // are only used it asserts and it may be overkill to compute them.
+    bool areOperandTypesLegal = llvm::all_of(
+        operands.getTypes(), [&](Type t) { return typeConverter.isLegal(t); });
+    bool areResultsTypesLegal = llvm::all_of(
+        resultTypes, [&](Type t) { return typeConverter.isLegal(t); });
+#endif // NDEBUG
+
+    // Add materialization and remember materialized results.
+    SmallVector<Value> materializedResults;
+    if (castKind == castKindNames.at(CastKind::Target)) {
+      // Target materialization.
+      assert(!areOperandTypesLegal && areResultsTypesLegal &&
+             operands.size() == 1 && "found unexpected target cast");
+      std::optional<SmallVector<Value>> maybeResults =
+          typeConverter.materializeTargetConversion(
+              rewriter, castOp->getLoc(), resultTypes, operands.front());
+      if (!maybeResults) {
+        emitError(castOp->getLoc())
+            << "failed to create target materialization";
+        return failure();
+      }
+      materializedResults = maybeResults.value();
+    } else {
+      // Source and argument materializations.
+      assert(areOperandTypesLegal && !areResultsTypesLegal &&
+             resultTypes.size() == 1 && "found unexpected cast");
+      std::optional<Value> maybeResult;
+      if (castKind == castKindNames.at(CastKind::Source)) {
+        // Source materialization.
+        maybeResult = typeConverter.materializeSourceConversion(
+            rewriter, castOp->getLoc(), resultTypes.front(),
+            castOp.getOperands());
+      } else {
+        // Argument materialization.
+        assert(castKind == castKindNames.at(CastKind::Argument) &&
+               "unexpected value of cast kind attribute");
+        assert(llvm::all_of(operands,
+                            [&](Value v) { return v.isa<BlockArgument>(); }));
+        maybeResult = typeConverter.materializeArgumentConversion(
+            rewriter, castOp->getLoc(), resultTypes.front(),
+            castOp.getOperands());
+      }
+      if (!maybeResult.has_value() || !maybeResult.value()) {
+        emitError(castOp->getLoc())
+            << "failed to create " << castKind << " materialization";
+        return failure();
+      }
+      materializedResults = {maybeResult.value()};
+    }
+
+    // Replace the cast with the result of the materialization.
+    rewriter.replaceOp(castOp, materializedResults);
+  }
+
+  return success();
+}
+
+} // namespace mlir

mlir/test/lib/Conversion/OneToNTypeConversion/OneToNTypeConversionFunc.h

+//===- OneToNTypeConversionFunc.h - 1:N type conversion for Func-*- C++ -*-===//
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSIONFUNC_H
+#define TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSIONFUNC_H
+
+namespace mlir {
+class TypeConverter;
+class RewritePatternSet;
+} // namespace mlir
+
+namespace mlir {
+
+// Populates the provided pattern set with patterns that do 1:N type conversions
+// on func ops. This is intended to be used with applyOneToNConversion.
+void populateFuncTypeConversionPatterns(TypeConverter &typeConverter,
+                                        RewritePatternSet &patterns);
+
+} // namespace mlir
+
+#endif // TEST_LIB_CONVERSION_ONETONTYPECONVERSION_ONETONTYPECONVERSIONFUNC_H

mlir/test/lib/Conversion/OneToNTypeConversion/OneToNTypeConversionFunc.cpp

+//===-- OneToNTypeConversionFunc.cpp - Func 1:N type conversion -*- C++ -*-===//
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// The patterns in this file are heavily inspired (and copied from)
+// convertFuncOpTypes in lib/Transforms/Utils/DialectConversion.cpp and the
+// patterns in lib/Dialect/Func/Transforms/FuncConversions.cpp but work for 1:N
+// type conversions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "OneToNTypeConversionFunc.h"
+
+#include "OneToNTypeConversion.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+
+using namespace mlir;
+using namespace mlir::func;
+
+class ConvertTypesInFuncCallOp : public OneToNOpConversionPattern<CallOp> {
+public:
+  using OneToNOpConversionPattern<CallOp>::OneToNOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(CallOp op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const override {
+    Location loc = op->getLoc();
+
+    // Nothing to do if the op doesn't have any non-identity conversions for its
+    // operands or results.
+    if (!operandMapping.hasNonIdentityConversion() &&
+        !resultMapping.hasNonIdentityConversion())
+      return failure();
+
+    // Create new CallOp.
+    auto newOp = rewriter.create<CallOp>(loc, resultMapping.getConvertedTypes(),
+                                         convertedOperands);
+    newOp->setAttrs(op->getAttrs());
+
+    rewriter.replaceOp(op, SmallVector<Value>(newOp->getResults()),
+                       resultMapping);
+    return success();
+  }
+};
+
+class ConvertTypesInFuncFuncOp : public OneToNOpConversionPattern<FuncOp> {
+public:
+  using OneToNOpConversionPattern<FuncOp>::OneToNOpConversionPattern;
+
+  LogicalResult matchAndRewrite(
+      FuncOp op, OneToNPatternRewriter &rewriter,
+      const OneToNTypeMapping & /*operandMapping*/,
+      const OneToNTypeMapping & /*resultMapping*/,
+      const SmallVector<Value> & /*convertedOperands*/) const override {
+    auto *typeConverter = getTypeConverter<OneToNTypeConverter>();
+
+    // Construct mapping for function arguments.
+    OneToNTypeMapping argumentMapping(op.getArgumentTypes());
+    if (failed(typeConverter->computeTypeMapping(op.getArgumentTypes(),
+                                                 argumentMapping)))
+      return failure();
+
+    // Construct mapping for function results.
+    OneToNTypeMapping funcResultMapping(op.getResultTypes());
+    if (failed(typeConverter->computeTypeMapping(op.getResultTypes(),
+                                                 funcResultMapping)))
+      return failure();
+
+    // Nothing to do if the op doesn't have any non-identity conversions for its
+    // operands or results.
+    if (!argumentMapping.hasNonIdentityConversion() &&
+        !funcResultMapping.hasNonIdentityConversion())
+      return failure();
+
+    // Update the function signature in-place.
+    auto newType = FunctionType::get(rewriter.getContext(),
+                                     argumentMapping.getConvertedTypes(),
+                                     funcResultMapping.getConvertedTypes());
+    rewriter.updateRootInPlace(op, [&] { op.setType(newType); });
+
+    // Update block signatures.
+    if (!op.isExternal()) {
+      Region *region = &op.getBody();
+      Block *block = &region->front();
+      rewriter.applySignatureConversion(block, argumentMapping);
+    }
+
+    return success();
+  }
+};
+
+class ConvertTypesInFuncReturnOp : public OneToNOpConversionPattern<ReturnOp> {
+public:
+  using OneToNOpConversionPattern<ReturnOp>::OneToNOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(ReturnOp op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping & /*resultMapping*/,
+                  const SmallVector<Value> &convertedOperands) const override {
+    // Nothing to do if there is no non-identity conversion.
+    if (!operandMapping.hasNonIdentityConversion())
+      return failure();
+
+    // Convert operands.
+    rewriter.updateRootInPlace(op, [&] { op->setOperands(convertedOperands); });
+
+    return success();
+  }
+};
+
+namespace mlir {
+
+void populateFuncTypeConversionPatterns(TypeConverter &typeConverter,
+                                        RewritePatternSet &patterns) {
+  patterns.add<
+      // clang-format off
+      ConvertTypesInFuncCallOp,
+      ConvertTypesInFuncFuncOp,
+      ConvertTypesInFuncReturnOp
+      // clang-format on
+      >(typeConverter, patterns.getContext());
+}
+
+} // namespace mlir

mlir/test/lib/Conversion/OneToNTypeConversion/TestOneToNTypeConversionPass.cpp

+//===- TestOneToNTypeConversion.cpp - Test 1:N type conversion utils ------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "OneToNTypeConversion.h"
+#include "OneToNTypeConversionFunc.h"
+#include "TestDialect.h"
+#include "mlir/Pass/Pass.h"
+
+using namespace mlir;
+
+namespace {
+/// Test pass that exercises the (poor-man's) 1:N type conversion mechanisms
+/// from this folder by converting built-in tuples to the elements they consist
+/// of as well as some dummy ops operating on these tuples.
+struct TestOneToNTypeConversionPass
+    : public PassWrapper<TestOneToNTypeConversionPass,
+                         OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOneToNTypeConversionPass)
+
+  TestOneToNTypeConversionPass() = default;
+  TestOneToNTypeConversionPass(const TestOneToNTypeConversionPass &pass)
+      : PassWrapper(pass) {}
+
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<test::TestDialect>();
+  }
+
+  StringRef getArgument() const final {
+    return "test-one-to-n-type-conversion";
+  }
+
+  StringRef getDescription() const final {
+    return "Test pass for 1:N type conversion";
+  }
+
+  Option<bool> convertFuncOps{*this, "convert-func-ops",
+                              llvm::cl::desc("Enable conversion on func ops"),
+                              llvm::cl::init(false)};
+
+  Option<bool> convertTupleOps{*this, "convert-tuple-ops",
+                               llvm::cl::desc("Enable conversion on tuple ops"),
+                               llvm::cl::init(false)};
+
+  void runOnOperation() override;
+};
+
+} // namespace
+
+namespace mlir {
+namespace test {
+void registerTestOneToNTypeConversionPass() {
+  PassRegistration<TestOneToNTypeConversionPass>();
+}
+} // namespace test
+} // namespace mlir
+
+/// Test pattern on for the `make_tuple` op from the test dialect that converts
+/// this kind of op into it's "decomposed" form, i.e., the elements of the tuple
+/// that is being produced by `test.make_tuple`, which are really just the
+/// operands of this op.
+class ConvertMakeTupleOp
+    : public OneToNOpConversionPattern<::test::MakeTupleOp> {
+public:
+  using OneToNOpConversionPattern<
+      ::test::MakeTupleOp>::OneToNOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(::test::MakeTupleOp op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const override {
+    // Simply replace the current op with the converted operands.
+    rewriter.replaceOp(op, convertedOperands, resultMapping);
+    return success();
+  }
+};
+
+/// Test pattern on for the `get_tuple_element` op from the test dialect that
+/// converts this kind of op into it's "decomposed" form, i.e., instead of
+/// "physically" extracting one element from the tuple, we forward the one
+/// element of the decomposed form that is being extracted (or the several
+/// elements in case that element is a nested tuple).
+class ConvertGetTupleElementOp
+    : public OneToNOpConversionPattern<::test::GetTupleElementOp> {
+public:
+  using OneToNOpConversionPattern<
+      ::test::GetTupleElementOp>::OneToNOpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(::test::GetTupleElementOp op, OneToNPatternRewriter &rewriter,
+                  const OneToNTypeMapping &operandMapping,
+                  const OneToNTypeMapping &resultMapping,
+                  const SmallVector<Value> &convertedOperands) const override {
+    // Construct mapping for tuple element types.
+    auto stateType = op->getOperand(0).getType().cast<TupleType>();
+    TypeRange originalElementTypes = stateType.getTypes();
+    OneToNTypeMapping elementMapping(originalElementTypes);
+    if (failed(typeConverter->convertSignatureArgs(originalElementTypes,
+                                                   elementMapping)))
+      return failure();
+
+    // Compute converted operands corresponding to original input tuple.
+    ValueRange convertedTuple =
+        operandMapping.getConvertedValues(convertedOperands, 0);
+
+    // Got those converted operands that correspond to the index-th element of
+    // the original input tuple.
+    size_t index = op.getIndex();
+    ValueRange extractedElement =
+        elementMapping.getConvertedValues(convertedTuple, index);
+
+    rewriter.replaceOp(op, extractedElement, resultMapping);
+
+    return success();
+  }
+};
+
+static void populateDecomposeTuplesTestPatterns(TypeConverter &typeConverter,
+                                                RewritePatternSet &patterns) {
+  patterns.add<
+      // clang-format off
+      ConvertMakeTupleOp,
+      ConvertGetTupleElementOp
+      // clang-format on
+      >(typeConverter, patterns.getContext());
+}
+
+/// Creates a sequence of `test.get_tuple_element` ops for all elements of a
+/// given tuple value. If some tuple elements are, in turn, tuples, the elements
+/// of those are extracted recursively such that the returned values have the
+/// same types as `resultTypes.getFlattenedTypes()`.
+///
+/// This function has been copied (with small adaptions) from
+/// TestDecomposeCallGraphTypes.cpp.
+static std::optional<SmallVector<Value>>
+buildGetTupleElementOps(OpBuilder &builder, TypeRange resultTypes, Value input,
+                        Location loc) {
+  TupleType inputType = input.getType().dyn_cast<TupleType>();
+  if (!inputType)
+    return {};
+
+  SmallVector<Value> values;
+  for (auto [idx, elementType] : llvm::enumerate(inputType.getTypes())) {
+    Value element = builder.create<::test::GetTupleElementOp>(
+        loc, elementType, input, builder.getI32IntegerAttr(idx));
+    if (auto nestedTupleType = elementType.dyn_cast<TupleType>()) {
+      // Recurse if the current element is also a tuple.
+      SmallVector<Type> flatRecursiveTypes;
+      nestedTupleType.getFlattenedTypes(flatRecursiveTypes);
+      std::optional<SmallVector<Value>> resursiveValues =
+          buildGetTupleElementOps(builder, flatRecursiveTypes, element, loc);
+      if (!resursiveValues.has_value())
+        return {};
+      values.append(resursiveValues.value());
+    } else {
+      values.push_back(element);
+    }
+  }
+  return values;
+}
+
+/// Creates a `test.make_tuple` op out of the given inputs building a tuple of
+/// type `resultType`. If that type is nested, each nested tuple is built
+/// recursively with another `test.make_tuple` op.
+///
+/// This function has been copied (with small adaptions) from
+/// TestDecomposeCallGraphTypes.cpp.
+static std::optional<Value> buildMakeTupleOp(OpBuilder &builder,
+                                             TupleType resultType,
+                                             ValueRange inputs, Location loc) {
+  // Build one value for each element at this nesting level.
+  SmallVector<Value> elements;
+  elements.reserve(resultType.getTypes().size());
+  ValueRange::iterator inputIt = inputs.begin();
+  for (Type elementType : resultType.getTypes()) {
+    if (auto nestedTupleType = elementType.dyn_cast<TupleType>()) {
+      // Determine how many input values are needed for the nested elements of
+      // the nested TupleType and advance inputIt by that number.
+      // TODO: We only need the *number* of nested types, not the types itself.
+      //       Maybe it's worth adding a more efficient overload?
+      SmallVector<Type> nestedFlattenedTypes;
+      nestedTupleType.getFlattenedTypes(nestedFlattenedTypes);
+      size_t numNestedFlattenedTypes = nestedFlattenedTypes.size();
+      ValueRange nestedFlattenedelements(inputIt,
+                                         inputIt + numNestedFlattenedTypes);
+      inputIt += numNestedFlattenedTypes;
+
+      // Recurse on the values for the nested TupleType.
+      std::optional<Value> res = buildMakeTupleOp(builder, nestedTupleType,
+                                                  nestedFlattenedelements, loc);
+      if (!res.has_value())
+        return {};
+
+      // The tuple constructed by the conversion is the element value.
+      elements.push_back(res.value());
+    } else {
+      // Base case: take one input as is.
+      elements.push_back(*inputIt++);
+    }
+  }
+
+  // Assemble the tuple from the elements.
+  return builder.create<::test::MakeTupleOp>(loc, resultType, elements);
+}
+
+void TestOneToNTypeConversionPass::runOnOperation() {
+  ModuleOp module = getOperation();
+  auto *context = &getContext();
+
+  // Assemble type converter.
+  OneToNTypeConverter typeConverter;
+
+  typeConverter.addConversion([](Type type) { return type; });
+  typeConverter.addConversion(
+      [](TupleType tupleType, SmallVectorImpl<Type> &types) {
+        tupleType.getFlattenedTypes(types);
+        return success();
+      });
+
+  typeConverter.addArgumentMaterialization(buildMakeTupleOp);
+  typeConverter.addSourceMaterialization(buildMakeTupleOp);
+  typeConverter.addTargetMaterialization(buildGetTupleElementOps);
+
+  // Assemble patterns.
+  RewritePatternSet patterns(context);
+  if (convertTupleOps)
+    populateDecomposeTuplesTestPatterns(typeConverter, patterns);
+  if (convertFuncOps)
+    populateFuncTypeConversionPatterns(typeConverter, patterns);
+
+  // Run conversion.
+  if (failed(applyOneToNConversion(module, typeConverter, std::move(patterns))))
+    return signalPassFailure();
+}

mlir/tools/mlir-opt/CMakeLists.txt

set(test_libs
     MLIRSCFTestPasses
     MLIRShapeTestPasses
     MLIRSPIRVTestPasses
     MLIRTensorTestPasses
     MLIRTestAnalysis
     MLIRTestDialect
     MLIRTestDynDialect
     MLIRTestIR
+    MLIRTestOneToNTypeConversionPass
     MLIRTestPass
     MLIRTestPDLL
     MLIRTestReducer
     MLIRTestRewrite
     MLIRTestTransformDialect
     MLIRTestTransforms
     MLIRTilingInterfaceTestPasses
     MLIRVectorTestPasses

mlir/tools/mlir-opt/mlir-opt.cpp

 void registerTestLoopMappingPass();
 void registerTestLoopUnrollingPass();
 void registerTestLowerToLLVM();
 void registerTestMatchReductionPass();
 void registerTestMathAlgebraicSimplificationPass();
 void registerTestMathPolynomialApproximationPass();
 void registerTestMemRefDependenceCheck();
 void registerTestMemRefStrideCalculation();
+void registerTestOneToNTypeConversionPass();
 void registerTestOpaqueLoc();
 void registerTestPadFusion();
 void registerTestPDLByteCodePass();
 void registerTestPDLLPasses();
 void registerTestPreparationPassWithAllowedMemrefResults();
 void registerTestRecursiveTypesPass();
 void registerTestSCFUtilsPass();
 void registerTestSCFWhileOpBuilderPass();
#endif
   mlir::test::registerTestLoopMappingPass();
   mlir::test::registerTestLoopUnrollingPass();
   mlir::test::registerTestLowerToLLVM();
   mlir::test::registerTestMatchReductionPass();
   mlir::test::registerTestMathAlgebraicSimplificationPass();
   mlir::test::registerTestMathPolynomialApproximationPass();
   mlir::test::registerTestMemRefDependenceCheck();
   mlir::test::registerTestMemRefStrideCalculation();
+  mlir::test::registerTestOneToNTypeConversionPass();
   mlir::test::registerTestOpaqueLoc();
   mlir::test::registerTestPadFusion();
   mlir::test::registerTestPDLByteCodePass();
   mlir::test::registerTestPDLLPasses();
   mlir::test::registerTestRecursiveTypesPass();
   mlir::test::registerTestSCFUtilsPass();
   mlir::test::registerTestSCFWhileOpBuilderPass();
   mlir::test::registerTestShapeMappingPass();