[mlir][OpFormatGen] Add support for resolving variadic types from non-variadic

[rriddle]

Summary

This enables better support for traits such as SameOperandsAndResultType, and other situations in which a variadic operand may be resolved from a non-variadic.

[stephenneuendorffer]

I don't see anything else obviously wrong, but I don't particularly grok what the code is doing either.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

848

variadic is misspelled

[rriddle]

Resolve comments

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

: TEST_Op<"format_two_variadic_operands_no_buildable_type_op",
               [AttrSizedOperandSegments]> {
   let arguments = (ins Variadic<AnyType>:$a,
                        Variadic<AnyType>:$b);
   let assemblyFormat = [{
     `(` $a `:` type($a) `)` `->` `(` $b `:` type($b) `)`  attr-dict
   }];
 }
 
+def FormatInferVariadicTypeFromNonVariadic
+    : TEST_Op<"format_infer_variadic_type_from_non_variadic",
+              [SameOperandsAndResultType]> {
+  let arguments = (ins Variadic<AnyType>:$operands);
+  let results = (outs AnyType:$result);
+  let assemblyFormat = "$operands attr-dict `:` type($result)";
+}
+
 //===----------------------------------------------------------------------===//
 // Test SideEffects
 //===----------------------------------------------------------------------===//
 
 def SideEffectOp : TEST_Op<"side_effect_op",
     [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let results = (outs AnyType:$result);
 }

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

 // CHECK: test.format_optional_operand_result_b_op(%[[I64]] : i64) : i64
 test.format_optional_operand_result_b_op(%i64 : i64) : i64
 
 // CHECK: test.format_optional_operand_result_b_op : i64
 test.format_optional_operand_result_b_op( : ) : i64
 
 // CHECK: test.format_optional_operand_result_b_op : i64
 test.format_optional_operand_result_b_op : i64
+
+//===----------------------------------------------------------------------===//
+// Format trait type inference
+//===----------------------------------------------------------------------===//
+
+// CHECK: test.format_infer_variadic_type_from_non_variadic %[[I64]], %[[I64]] : i64
+test.format_infer_variadic_type_from_non_variadic %i64, %i64 : i64

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (allOperands) {
     return;
   }
 
   // The final case is the one where each of the operands types are resolved
   // separately.
   for (unsigned i = 0, e = op.getNumOperands(); i != e; ++i) {
     NamedTypeConstraint &operand = op.getOperand(i);
     body << "  if (parser.resolveOperands(" << operand.name << "Operands, ";
-    emitTypeResolver(operandTypes[i], operand.name);
 
-    // If this isn't a buildable type, verify the sizes match by adding the loc.
-    if (!operandTypes[i].getBuilderIdx())
+    // Resolve the type of this operand.
+    TypeResolution &operandType = operandTypes[i];
+    emitTypeResolver(operandType, operand.name);
+
+    // If the type is resolved by a non-variadic variable, index into the
+    // resolved type list. This allows for resolving the types of a variadic
+    // operand list from a non-variadic variable.
+    bool verifyOperandAndTypeSize = true;
+    if (auto *resolverVar = operandType.getVariable()) {
+      if (!resolverVar->isVariadic() && !operandType.getVarTransformer()) {
+        body << "[0]";
+        verifyOperandAndTypeSize = false;
+      }
+    } else {
+      verifyOperandAndTypeSize = !operandType.getBuilderIdx();
+    }
+
+    // Check to see if the sizes between the types and operands must match. If
+    // they do, provide the operand location to select the proper resolution
+    // overload.
+    if (verifyOperandAndTypeSize)
       body << ", " << operand.name << "OperandsLoc";
     body << ", result.operands))\n    return failure();\n";
   }
 }
 
 void OperationFormat::genParserSuccessorResolution(Operator &op,
                                                    OpMethodBody &body) {
   // Check for the case where all successors were parsed.