[NFC] Add unit tests for printing/parsing of variadic operands and results.

[rriddle]

mlir/test/lib/Dialect/Test/TestOps.td

1531

nit: <> is really awkward to see(I don't think I've ever seen it used this way, just use [] instead.

[rriddle]

mlir/test/lib/Dialect/Test/TestOps.td

1531

Or ()

[jurahul]

Fix nit

mlir/test/lib/Dialect/Test/TestOps.td

 }]>;
 def FormatResultBOp : FormatResultBase<"b", [{
   type(results) attr-dict
 }]>;
 def FormatResultCOp : FormatResultBase<"c", [{
   functional-type($buildable_res, $result) attr-dict
 }]>;
 
+def FormatVariadicResult : TEST_Op<"format_variadic_result"> {
+  let results = (outs Variadic<I64>:$result);
+  let assemblyFormat = [{ `:` type($result) attr-dict}];
+}
+
+def FormatMultipleVariadicResults : TEST_Op<"format_multiple_variadic_results",
+                                            [AttrSizedResultSegments]> {
+  let results = (outs Variadic<I64>:$result0, Variadic<AnyType>:$result1);
+  let assemblyFormat = [{
+    `:` `(` type($result0) `)` `,` `(` type($result1) `)` attr-dict
+  }];
+}
+
 // Test various mixings of operand type formatting.
 class FormatOperandBase<string suffix, string fmt>
     : TEST_Op<"format_operand_" # suffix # "_op"> {
   let arguments = (ins I64:$buildable, AnyMemRef:$operand);
   let assemblyFormat = fmt;
 }
 
 def FormatOperandAOp : FormatOperandBase<"a", [{
def FormatOperandEOp : FormatOperandBase<"e", [{
   $buildable `,` $operand `:` type($buildable) `,` type($operand) attr-dict
 }]>;
 
 def FormatSuccessorAOp : TEST_Op<"format_successor_a_op", [Terminator]> {
   let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
   let assemblyFormat = "$targets attr-dict";
 }
 
+def FormatVariadicOperand : TEST_Op<"format_variadic_operand"> {
+  let arguments = (ins Variadic<I64>:$operand);
+  let assemblyFormat = [{ $operand `:` type($operand) attr-dict}];
+}
+
+def FormatMultipleVariadicOperands :
+    TEST_Op<"format_multiple_variadic_operands", [AttrSizedOperandSegments]> {
+  let arguments = (ins Variadic<I64>:$operand0, Variadic<AnyType>:$operand1);
+  let assemblyFormat = [{
+    ` ` `(` $operand0 `)` `,` `(` $operand1 `:` type($operand1) `)` attr-dict
+  }];
+}
+
 // Test various mixings of optional operand and result type formatting.
 class FormatOptionalOperandResultOpBase<string suffix, string fmt>
     : TEST_Op<"format_optional_operand_result_" # suffix # "_op",
               [AttrSizedOperandSegments]> {
   let arguments = (ins Optional<I64>:$optional, Variadic<I64>:$variadic);
   let results = (outs Optional<I64>:$optional_res);
   let assemblyFormat = fmt;
 }

mlir/test/mlir-tblgen/op-format.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s | mlir-opt -allow-unregistered-dialect -verify-diagnostics | FileCheck %s
 
 // CHECK: %[[I64:.*]] =
 %i64 = "foo.op"() : () -> (i64)
+// CHECK: %[[I32:.*]] =
+%i32 = "foo.op"() : () -> (i32)
 // CHECK: %[[MEMREF:.*]] =
 %memref = "foo.op"() : () -> (memref<1xf64>)
 
 // CHECK: test.format_literal_op keyword_$. -> :, = <> () []( ) ? + * {foo.some_attr}
 test.format_literal_op keyword_$. -> :, = <> () []( ) ? + * {foo.some_attr}
 
 // CHECK: test.format_attr_op 10
 // CHECK-NOT: {attr

 %ignored_a:2 = test.format_result_a_op memref<1xf64>
 
 // CHECK: test.format_result_b_op i64, memref<1xf64>
 %ignored_b:2 = test.format_result_b_op i64, memref<1xf64>
 
 // CHECK: test.format_result_c_op (i64) -> memref<1xf64>
 %ignored_c:2 = test.format_result_c_op (i64) -> memref<1xf64>
 
+// CHECK: test.format_variadic_result : i64, i64, i64
+%ignored_v:3 = test.format_variadic_result : i64, i64, i64
+
+// CHECK: test.format_multiple_variadic_results : (i64, i64, i64), (i32, i32)
+%ignored_mv:5 = test.format_multiple_variadic_results : (i64, i64, i64), (i32, i32)
+
 //===----------------------------------------------------------------------===//
 // Format operands
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_operand_a_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_a_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_b_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_b_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_c_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_c_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_d_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_d_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_e_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_e_op %i64, %memref : i64, memref<1xf64>
 
+// CHECK: test.format_variadic_operand %[[I64]], %[[I64]], %[[I64]] : i64, i64, i64
+test.format_variadic_operand %i64, %i64, %i64 : i64, i64, i64
+
+// CHECK: test.format_multiple_variadic_operands (%[[I64]], %[[I64]], %[[I64]]), (%[[I64]], %[[I32]] : i64, i32)
+test.format_multiple_variadic_operands (%i64, %i64, %i64), (%i64, %i32 : i64, i32)
+
 //===----------------------------------------------------------------------===//
 // Format successors
 //===----------------------------------------------------------------------===//
 
 "foo.successor_test_region"() ( {
   ^bb0:
     // CHECK: test.format_successor_a_op ^bb1 {attr}
     test.format_successor_a_op ^bb1 {attr}