[mlir][irdl] Support variadicity check in operations

[math-fehr]

Summary

This patch adds support for loading IRDL operations that are
using optional or variadics operands and results.

If an operation declares more than one optional/variadic operand
or result, then it requires the segment sizes in the attribute
dictionary, and otherwise it is computed using the number of
operands or results.

Currently, a variadic operand or result definiton expects all
operands and results in that definition to have the same type.
This restriction will be removed in a following patch.

Depends on D153983

[Mogball]

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

56

70

please add braces here

77

97

same here

99

please use static_cast

113

125

please spell out this auto

133

please use static_cast

249

please use prefix, and above as well

304

drop trivial braces

325

here too

[unterumarmung]

Thank you for adding me to the review
I honestly learned something new about MLIR while reviewing this :)
I left my suggestions below

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

77–79

llvm::enumerate with more than one argument actually zips them also

96–98

Yet, std::reduce is C++17 feature and may not be supported by the minimum version compilers required by MLIR
In that case, it may be replaced with std::accumulate

P.S. For some reason there are no llvm::accumulate or llvm::reduce in the STLExtras.h

131–138

It seems like this whole check could be moved outside of a loop because it is not dependent on the variadicity variable

133

Probably should be renamed to something like nonSingleSegmentSize

137

Is variadicities.size() exact enough value to represent, for example, number of minimal expected operands?
Say we have: irdl.operands(single %0, optional %1, single %2). As far as I understand, it is a possible situation in this code because we have only one non-single operand.
So, minimal number of expected operands is actually 2 but the error would say 3

Sorry to be picky about this, this might not be so important

140

286–304

Optional suggestion

If you do not want to use the "algorithm", there is other way to make code more nice:

SmallVector<Variadicity> operandVariadicity(operandsOp->getVariadicity().size());
for (auto& [attr, variadicity] : llvm::zip(operandsOp->getVariadicity(), operandVariadicity)) {
  variadicity = attr.cast<VariadicityAttr>().getValue();
}

323

Same here for the loop

[math-fehr]

Address comments, and add missing tests

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

96–98

Oh yes thanks! MLIR is now using C++17, so hopefully std::accumulate sholud work!

131–138

Right, I rewrote this part a bit to make it more readable!

137

Oh yes you are totally right, this is not picky at all and the error message is important!
Here it should be variadicities.size() - 1, since you have n-1 operands for the single ones, and then the optional/variadic operand can be empty.

286–304

Hmm, here I would actually prefer the original version, since it is only a simple for loop. I feel that adding transform or the zip with assignment adds a bit too much of complexity, what do you think? @Mogball, what would be the most LLVM-like way of writing that?

[unterumarmung]

LGTM

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

286–304

I'd prefer calling reserve for the given size or passing the size value to the constructor.
Just in terms of efficiency.

[math-fehr]

Ping @Mogball

[math-fehr]

Update to main

[math-fehr]

Update to latest main

[math-fehr]

Reopen, as buildbot failed because of std::reduce

[math-fehr]

Remove uses of std::reduce

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/SMLoc.h"
+#include <numeric>
 
 using namespace mlir;
 using namespace mlir::irdl;
 
 /// Verify that the given list of parameters satisfy the given constraints.
 /// This encodes the logic of the verification method for attributes and types
 /// defined with IRDL.
 static LogicalResult
irdlAttrOrTypeVerifier(function_ref<InFlightDiagnostic()> emitError,
   // Check that each parameter satisfies its constraint.
   for (auto [i, param] : enumerate(params))
     if (failed(verifier.verify(emitError, param, paramConstraints[i])))
       return failure();
 
   return success();
 }
 
+/// Get the operand segment sizes from the attribute dictionary.
+LogicalResult getSegmentSizesFromAttr(Operation *op, StringRef elemName,
+                                      StringRef attrName, unsigned numElements,
+                                      ArrayRef<Variadicity> variadicities,
+                                      SmallVectorImpl<int> &segmentSizes) {
+  // Get the segment sizes attribute, and check that it is of the right type.
+  Attribute segmentSizesAttr = op->getAttr(attrName);
+  if (!segmentSizesAttr) {
+    return op->emitError() << "'" << attrName
+                           << "' attribute is expected but not provided";
+  }
+
+  auto denseSegmentSizes = dyn_cast<DenseI32ArrayAttr>(segmentSizesAttr);
+  if (!denseSegmentSizes) {
+    return op->emitError() << "'" << attrName
+                           << "' attribute is expected to be a dense i32 array";
+  }
+
+  if (denseSegmentSizes.size() != (int64_t)variadicities.size()) {
+    return op->emitError() << "'" << attrName << "' attribute for specifying "
+                           << elemName << " segments must have "
+                           << variadicities.size() << " elements, but got "
+                           << denseSegmentSizes.size();
+  }
+
+  // Check that the segment sizes are corresponding to the given variadicities,
+  for (auto [i, segmentSize, variadicity] :
+       enumerate(denseSegmentSizes.asArrayRef(), variadicities)) {
+    if (segmentSize < 0)
+      return op->emitError()
+             << "'" << attrName << "' attribute for specifying " << elemName
+             << " segments must have non-negative values";
+    if (variadicity == Variadicity::single && segmentSize != 1)
+      return op->emitError() << "element " << i << " in '" << attrName
+                             << "' attribute must be equal to 1";
+
+    if (variadicity == Variadicity::optional && segmentSize > 1)
+      return op->emitError() << "element " << i << " in '" << attrName
+                             << "' attribute must be equal to 0 or 1";
+
+    segmentSizes.push_back(segmentSize);
+  }
+
+  // Check that the sum of the segment sizes is equal to the number of elements.
+  int32_t sum = std::reduce(denseSegmentSizes.asArrayRef().begin(),
+                            denseSegmentSizes.asArrayRef().end(), 0);
+  if (sum != static_cast<int32_t>(numElements))
+    return op->emitError() << "sum of elements in '" << attrName
+                           << "' attribute must be equal to the number of "
+                           << elemName << "s";
+
+  return success();
+}
+
+/// Compute the segment sizes of the given element (operands, results).
+/// If the operation has more than two non-single elements (optional or
+/// variadic), then get the segment sizes from the attribute dictionary.
+/// Otherwise, compute the segment sizes from the number of elements.
+/// `elemName` should be either `"operand"` or `"result"`.
+LogicalResult getSegmentSizes(Operation *op, StringRef elemName,
+                              StringRef attrName, unsigned numElements,
+                              ArrayRef<Variadicity> variadicities,
+                              SmallVectorImpl<int> &segmentSizes) {
+  // If we have more than one non-single variadicity, we need to get the
+  // segment sizes from the attribute dictionary.
+  int numberNonSingle = count_if(
+      variadicities, [](Variadicity v) { return v != Variadicity::single; });
+  if (numberNonSingle > 1)
+    return getSegmentSizesFromAttr(op, elemName, attrName, numElements,
+                                   variadicities, segmentSizes);
+
+  // If we only have single variadicities, the segments sizes are all 1.
+  if (numberNonSingle == 0) {
+    if (numElements != variadicities.size()) {
+      return op->emitError() << "op expects exactly " << variadicities.size()
+                             << " " << elemName << "s, but got " << numElements;
+    }
+    for (size_t i = 0, e = variadicities.size(); i < e; ++i)
+      segmentSizes.push_back(1);
+    return success();
+  }
+
+  assert(numberNonSingle == 1);
+
+  // There is exactly one non-single element, so we can
+  // compute its size and check that it is valid.
+  int nonSingleSegmentSize = static_cast<int>(numElements) -
+                             static_cast<int>(variadicities.size()) + 1;
+
+  if (nonSingleSegmentSize < 0) {
+    return op->emitError() << "op expects at least " << variadicities.size() - 1
+                           << " " << elemName << "s, but got " << numElements;
+  }
+
+  // Add the segment sizes.
+  for (Variadicity variadicity : variadicities) {
+    if (variadicity == Variadicity::single) {
+      segmentSizes.push_back(1);
+      continue;
+    }
+
+    // If we have an optional element, we should check that it represents
+    // zero or one elements.
+    if (nonSingleSegmentSize > 1 && variadicity == Variadicity::optional)
+      return op->emitError() << "op expects at most " << variadicities.size()
+                             << " " << elemName << "s, but got " << numElements;
+
+    segmentSizes.push_back(nonSingleSegmentSize);
+  }
+
+  return success();
+}
+
+/// Compute the segment sizes of the given operands.
+/// If the operation has more than two non-single operands (optional or
+/// variadic), then get the segment sizes from the attribute dictionary.
+/// Otherwise, compute the segment sizes from the number of operands.
+LogicalResult getOperandSegmentSizes(Operation *op,
+                                     ArrayRef<Variadicity> variadicities,
+                                     SmallVectorImpl<int> &segmentSizes) {
+  return getSegmentSizes(op, "operand", "operand_segment_sizes",
+                         op->getNumOperands(), variadicities, segmentSizes);
+}
+
+/// Compute the segment sizes of the given results.
+/// If the operation has more than two non-single results (optional or
+/// variadic), then get the segment sizes from the attribute dictionary.
+/// Otherwise, compute the segment sizes from the number of results.
+LogicalResult getResultSegmentSizes(Operation *op,
+                                    ArrayRef<Variadicity> variadicities,
+                                    SmallVectorImpl<int> &segmentSizes) {
+  return getSegmentSizes(op, "result", "result_segment_sizes",
+                         op->getNumResults(), variadicities, segmentSizes);
+}
+
 /// Verify that the given operation satisfies the given constraints.
 /// This encodes the logic of the verification method for operations defined
 /// with IRDL.
-static LogicalResult
-irdlOpVerifier(Operation *op, ArrayRef<std::unique_ptr<Constraint>> constraints,
-               ArrayRef<size_t> operandConstrs, ArrayRef<size_t> resultConstrs,
-               const DenseMap<StringAttr, size_t> &attributeConstrs) {
-  /// Check that we have the right number of operands.
-  unsigned numOperands = op->getNumOperands();
-  size_t numExpectedOperands = operandConstrs.size();
-  if (numOperands != numExpectedOperands)
-    return op->emitOpError() << numExpectedOperands
-                             << " operands expected, but got " << numOperands;
-
-  /// Check that we have the right number of results.
-  unsigned numResults = op->getNumResults();
-  size_t numExpectedResults = resultConstrs.size();
-  if (numResults != numExpectedResults)
-    return op->emitOpError()
-           << numExpectedResults << " results expected, but got " << numResults;
+static LogicalResult irdlOpVerifier(
+    Operation *op, ArrayRef<std::unique_ptr<Constraint>> constraints,
+    ArrayRef<size_t> operandConstrs, ArrayRef<Variadicity> operandVariadicity,
+    ArrayRef<size_t> resultConstrs, ArrayRef<Variadicity> resultVariadicity,
+  // Get the segment sizes for the operands.
+  // This will check that the number of operands is correct.
+  SmallVector<int> operandSegmentSizes;
+  if (failed(
+          getOperandSegmentSizes(op, operandVariadicity, operandSegmentSizes)))
+    return failure();
+
+  // Get the segment sizes for the results.
+  // This will check that the number of results is correct.
+  SmallVector<int> resultSegmentSizes;
+  if (failed(getResultSegmentSizes(op, resultVariadicity, resultSegmentSizes)))
+    return failure();
 
   auto emitError = [op] { return op->emitError(); };
 
   ConstraintVerifier verifier(constraints);
 
   /// Сheck that we have all needed attributes passed
   /// and they satisfy the constraints.
   DictionaryAttr actualAttrs = op->getAttrDictionary();
 
   for (auto [name, constraint] : attributeConstrs) {
     /// First, check if the attribute actually passed.
     std::optional<NamedAttribute> actual = actualAttrs.getNamed(name);
     if (!actual.has_value())
       return op->emitOpError()
              << "attribute " << name << " is expected but not provided";
 
     /// Then, check if the attribute value satisfies the constraint.
     if (failed(verifier.verify({emitError}, actual->getValue(), constraint)))
       return failure();
   }
 
-  /// Check that all operands satisfy the constraints.
-  for (auto [i, operandType] : enumerate(op->getOperandTypes()))
-    if (failed(verifier.verify({emitError}, TypeAttr::get(operandType),
-                               operandConstrs[i])))
-      return failure();
+  // Check that all operands satisfy the constraints
+  int operandIdx = 0;
+  for (auto [defIndex, segmentSize] : enumerate(operandSegmentSizes)) {
+    for (int i = 0; i < segmentSize; i++) {
+      if (failed(verifier.verify(
+              {emitError}, TypeAttr::get(op->getOperandTypes()[operandIdx]),
+              operandConstrs[defIndex])))
+        return failure();
+      ++operandIdx;
+    }
+  }
 
-  /// Check that all results satisfy the constraints.
-  for (auto [i, resultType] : enumerate(op->getResultTypes()))
-    if (failed(verifier.verify({emitError}, TypeAttr::get(resultType),
-                               resultConstrs[i])))
+  // Check that all results satisfy the constraints
+  int resultIdx = 0;
+  for (auto [defIndex, segmentSize] : enumerate(resultSegmentSizes)) {
+    for (int i = 0; i < segmentSize; i++) {
+      if (failed(verifier.verify({emitError},
+                                 TypeAttr::get(op->getResultTypes()[resultIdx]),
+                                 resultConstrs[defIndex])))
         return failure();
+      ++resultIdx;
+    }
+  }
 
   return success();
 }
 
 /// Define and load an operation represented by a `irdl.operation`
 /// operation.
 static WalkResult loadOperation(
     OperationOp op, ExtensibleDialect *dialect,
for (Value v : constrToValue) {
     std::unique_ptr<Constraint> verifier =
         op.getVerifier(constrToValue, types, attrs);
     if (!verifier)
       return WalkResult::interrupt();
     constraints.push_back(std::move(verifier));
   }
 
   SmallVector<size_t> operandConstraints;
-  SmallVector<size_t> resultConstraints;
+  SmallVector<Variadicity> operandVariadicity;
 
   // Gather which constraint slots correspond to operand constraints
   auto operandsOp = op.getOp<OperandsOp>();
   if (operandsOp.has_value()) {
     operandConstraints.reserve(operandsOp->getArgs().size());
     for (Value operand : operandsOp->getArgs()) {
       for (auto [i, constr] : enumerate(constrToValue)) {
         if (constr == operand) {
           operandConstraints.push_back(i);
           break;
         }
       }
     }
+
+    // Gather the variadicities of each operand
+    for (VariadicityAttr attr : operandsOp->getVariadicity())
+      operandVariadicity.push_back(attr.getValue());
   }
 
+  SmallVector<size_t> resultConstraints;
+  SmallVector<Variadicity> resultVariadicity;
+
   // Gather which constraint slots correspond to result constraints
   auto resultsOp = op.getOp<ResultsOp>();
   if (resultsOp.has_value()) {
     resultConstraints.reserve(resultsOp->getArgs().size());
     for (Value result : resultsOp->getArgs()) {
       for (auto [i, constr] : enumerate(constrToValue)) {
         if (constr == result) {
           resultConstraints.push_back(i);
           break;
         }
       }
     }
+
+    // Gather the variadicities of each result
+    for (Attribute attr : resultsOp->getVariadicity())
+      resultVariadicity.push_back(attr.cast<VariadicityAttr>().getValue());
   }
 
   // Gather which constraint slots correspond to attributes constraints
   DenseMap<StringAttr, size_t> attributesContraints;
   auto attributesOp = op.getOp<AttributesOp>();
   if (attributesOp.has_value()) {
     const Operation::operand_range values = attributesOp->getAttributeValues();
     const ArrayAttr names = attributesOp->getAttributeValueNames();
 
static WalkResult loadOperation(
   };
   auto printer = [](Operation *op, OpAsmPrinter &printer, StringRef) {
     printer.printGenericOp(op);
   };
 
   auto verifier =
       [constraints{std::move(constraints)},
        operandConstraints{std::move(operandConstraints)},
+       operandVariadicity{std::move(operandVariadicity)},
        resultConstraints{std::move(resultConstraints)},
+       resultVariadicity{std::move(resultVariadicity)},
        attributesContraints{std::move(attributesContraints)}](Operation *op) {
         return irdlOpVerifier(op, constraints, operandConstraints,
-                              resultConstraints, attributesContraints);
+                              operandVariadicity, resultConstraints,
+                              resultVariadicity, attributesContraints);
       };
 
   // IRDL does not support defining regions.
   auto regionVerifier = [](Operation *op) { return success(); };
 
   auto opDef = DynamicOpDefinition::get(
       op.getName(), dialect, std::move(verifier), std::move(regionVerifier),
       std::move(parser), std::move(printer));

mlir/test/Dialect/IRDL/variadics.irdl.mlir

irdl.operation @var_operand {
     %2 = irdl.is i64
     irdl.operands(%0, variadic %1, %2)
   }
 
   // CHECK-LABEL: irdl.operation @opt_operand {
   // CHECK-NEXT:    %[[v0:[^ ]*]] = irdl.is i16 
   // CHECK-NEXT:    %[[v1:[^ ]*]] = irdl.is i32 
   // CHECK-NEXT:    %[[v2:[^ ]*]] = irdl.is i64 
-  // CHECK-NEXT:    irdl.operands(%[[v0]], variadic %[[v1]], %[[v2]])
+  // CHECK-NEXT:    irdl.operands(%[[v0]], optional %[[v1]], %[[v2]])
   // CHECK-NEXT:  }
   irdl.operation @opt_operand {
     %0 = irdl.is i16
     %1 = irdl.is i32
     %2 = irdl.is i64
-    irdl.operands(%0, variadic %1, %2)
+    irdl.operands(%0, optional %1, %2)
   }
 
   // CHECK-LABEL: irdl.operation @var_and_opt_operand {
   // CHECK-NEXT:    %[[v0:[^ ]*]] = irdl.is i16 
   // CHECK-NEXT:    %[[v1:[^ ]*]] = irdl.is i32 
   // CHECK-NEXT:    %[[v2:[^ ]*]] = irdl.is i64 
   // CHECK-NEXT:    irdl.operands(variadic %[[v0]], optional %[[v1]], %[[v2]])
   // CHECK-NEXT:  }
irdl.operation @var_result {
     %2 = irdl.is i64
     irdl.results(%0, variadic %1, %2)
   }
 
   // CHECK-LABEL: irdl.operation @opt_result {
   // CHECK-NEXT:    %[[v0:[^ ]*]] = irdl.is i16 
   // CHECK-NEXT:    %[[v1:[^ ]*]] = irdl.is i32 
   // CHECK-NEXT:    %[[v2:[^ ]*]] = irdl.is i64 
-  // CHECK-NEXT:    irdl.results(%[[v0]], variadic %[[v1]], %[[v2]])
+  // CHECK-NEXT:    irdl.results(%[[v0]], optional %[[v1]], %[[v2]])
   // CHECK-NEXT:  }
   irdl.operation @opt_result {
     %0 = irdl.is i16
     %1 = irdl.is i32
     %2 = irdl.is i64
-    irdl.results(%0, variadic %1, %2)
+    irdl.results(%0, optional %1, %2)
   }
 
   // CHECK-LABEL: irdl.operation @var_and_opt_result {
   // CHECK-NEXT:    %[[v0:[^ ]*]] = irdl.is i16 
   // CHECK-NEXT:    %[[v1:[^ ]*]] = irdl.is i32 
   // CHECK-NEXT:    %[[v2:[^ ]*]] = irdl.is i64 
   // CHECK-NEXT:    irdl.results(variadic %[[v0]], optional %[[v1]], %[[v2]])
   // CHECK-NEXT:  }
   irdl.operation @var_and_opt_result {
     %0 = irdl.is i16
     %1 = irdl.is i32
     %2 = irdl.is i64
     irdl.results(variadic %0, optional %1, %2)
   }
 }

mlir/test/Dialect/IRDL/variadics.mlir

+// RUN: mlir-opt %s --irdl-file=%S/variadics.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+//===----------------------------------------------------------------------===//
+// Single operand
+//===----------------------------------------------------------------------===//
+
+// Test an operation with a single operand.
+func.func @testSingleOperand(%x: i32) {
+  "testvar.single_operand"(%x) : (i32) -> ()
+  // CHECK: "testvar.single_operand"(%{{.*}}) : (i32) -> ()
+  return
+}
+
+// -----
+
+// Test an operation with a single operand definition and a wrong number of operands.
+func.func @testSingleOperandFail(%x: i32) {
+  // expected-error@+1 {{op expects exactly 1 operands, but got 2}}
+  "testvar.single_operand"(%x, %x) : (i32, i32) -> ()  
+  return
+}
+
+// -----
+
+// Test an operation with a single operand definition and a wrong number of operands.
+func.func @testSingleOperandFail() {
+  // expected-error@+1 {{op expects exactly 1 operands, but got 0}}
+  "testvar.single_operand"() : () -> ()  
+  return
+}
+
+// -----
+
+
+//===----------------------------------------------------------------------===//
+// Variadic operand
+//===----------------------------------------------------------------------===//
+
+// Test an operation with a single variadic operand.
+func.func @testVarOperand(%x: i16, %y: i32, %z: i64) {
+  "testvar.var_operand"(%x, %z) : (i16, i64) -> ()
+  // CHECK: "testvar.var_operand"(%{{.*}}, %{{.*}}) : (i16, i64) -> ()
+  "testvar.var_operand"(%x, %y, %z) : (i16, i32, i64) -> ()
+  // CHECK-NEXT: "testvar.var_operand"(%{{.*}}, %{{.*}}, %{{.*}}) : (i16, i32, i64) -> ()
+  "testvar.var_operand"(%x, %y, %y, %z) : (i16, i32, i32, i64) -> ()
+  // CHECK-NEXT: "testvar.var_operand"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i16, i32, i32, i64) -> ()
+  "testvar.var_operand"(%x, %y, %y, %y, %z) : (i16, i32, i32, i32, i64) -> ()
+  // CHECK-NEXT: "testvar.var_operand"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i16, i32, i32, i32, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the verifier of a variadic operand  fails if the variadic is given
+// a wrong type.
+func.func @testVarOperandFail(%x: i16, %y: i64, %z: i64) {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.var_operand"(%x, %y, %z) : (i16, i64, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the verifier of a variadic operand fails if the variadic is given
+// a wrong type on the second value.
+func.func @testVarOperandFail(%x: i16, %y1: i32, %y2: i64, %z: i64) {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.var_operand"(%x, %y1, %y2, %z) : (i16, i32, i64, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that if we do not give enough operands, the verifier fails.
+func.func @testVarOperandFail() {
+  // expected-error@+1 {{op expects at least 2 operands, but got 0}}
+  "testvar.var_operand"() : () -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Optional operand
+//===----------------------------------------------------------------------===//
+
+
+// Test an operation with a single optional operand.
+func.func @testOptOperand(%x: i16, %y: i32, %z: i64) {
+  "testvar.opt_operand"(%x, %z) : (i16, i64) -> ()
+  // CHECK: "testvar.opt_operand"(%{{.*}}, %{{.*}}) : (i16, i64) -> ()
+  "testvar.opt_operand"(%x, %y, %z) : (i16, i32, i64) -> ()
+  // CHECK-NEXT: "testvar.opt_operand"(%{{.*}}, %{{.*}}, %{{.*}}) : (i16, i32, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional operand fails if the variadic is
+// given a wrong type.
+func.func @testOptOperandFail(%x: i16, %y: i64, %z: i64) {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.opt_operand"(%x, %y, %z) : (i16, i64, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional operand fails if there are too
+// many operands.
+func.func @testOptOperandFail(%x: i16, %y: i32, %z: i64) {
+  // expected-error@+1 {{op expects at most 3 operands, but got 4}}
+  "testvar.opt_operand"(%x, %y, %y, %z) : (i16, i32, i32, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional operand fails if there are not
+// enough operands.
+func.func @testOptOperandFail(%x: i16) {
+  // expected-error@+1 {{op expects at least 2 operands, but got 1}}
+  "testvar.opt_operand"(%x) : (i16) -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Multiple variadic
+//===----------------------------------------------------------------------===//
+
+// Check that an operation with multiple variadics expects the segment size
+// attribute
+func.func @testMultOperandsMissingSegment(%x: i16, %z: i64) {
+  // expected-error@+1 {{'operand_segment_sizes' attribute is expected but not provided}}
+  "testvar.var_and_opt_operand"(%x, %x, %z) : (i16, i16, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that an operation with multiple variadics expects the segment size
+// attribute of the right type
+func.func @testMultOperandsWrongSegmentType(%x: i16, %z: i64) {
+  // expected-error@+1 {{'operand_segment_sizes' attribute is expected to be a dense i32 array}}
+  "testvar.var_and_opt_operand"(%x, %x, %z) {operand_segment_sizes = i32} : (i16, i16, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that an operation with multiple variadics with the right segment size
+// verifies.
+func.func @testMultOperands(%x: i16, %y: i32, %z: i64) {
+  "testvar.var_and_opt_operand"(%x, %x, %z) {operand_segment_sizes = array<i32: 2, 0, 1>} : (i16, i16, i64) -> ()
+  // CHECK: "testvar.var_and_opt_operand"(%{{.*}}, %{{.*}}, %{{.*}}) {operand_segment_sizes = array<i32: 2, 0, 1>} : (i16, i16, i64) -> ()
+  "testvar.var_and_opt_operand"(%x, %x, %y, %z) {operand_segment_sizes = array<i32: 2, 1, 1>} : (i16, i16, i32, i64) -> ()
+  // CHECK-NEXT: "testvar.var_and_opt_operand"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {operand_segment_sizes = array<i32: 2, 1, 1>} : (i16, i16, i32, i64) -> ()
+  "testvar.var_and_opt_operand"(%y, %z) {operand_segment_sizes = array<i32: 0, 1, 1>} : (i32, i64) -> ()
+  // CHECK-NEXT: "testvar.var_and_opt_operand"(%{{.*}}, %{{.*}}) {operand_segment_sizes = array<i32: 0, 1, 1>} : (i32, i64) -> ()
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects non-negative values
+func.func @testMultOperandsSegmentNegative() {
+  // expected-error@+1 {{'operand_segment_sizes' attribute for specifying operand segments must have non-negative values}}
+  "testvar.var_and_opt_operand"() {operand_segment_sizes = array<i32: 2, -1, 1>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects 1 for single values
+func.func @testMultOperandsSegmentWrongSingle() {
+  // expected-error@+1 {{element 2 in 'operand_segment_sizes' attribute must be equal to 1}}
+  "testvar.var_and_opt_operand"() {operand_segment_sizes = array<i32: 0, 0, 0>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects not more than 1 for optional values
+func.func @testMultOperandsSegmentWrongOptional() {
+  // expected-error@+1 {{element 1 in 'operand_segment_sizes' attribute must be equal to 0 or 1}}
+  "testvar.var_and_opt_operand"() {operand_segment_sizes = array<i32: 0, 2, 0>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the sum of the segment sizes should be equal to the number of operands
+func.func @testMultOperandsSegmentWrongOptional(%y: i32, %z: i64) {
+  // expected-error@+1 {{sum of elements in 'operand_segment_sizes' attribute must be equal to the number of operands}}
+  "testvar.var_and_opt_operand"(%y, %z) {operand_segment_sizes = array<i32: 0, 0, 1>} : (i32, i64) -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Single result
+//===----------------------------------------------------------------------===//
+
+// Test an operation with a single result.
+func.func @testSingleResult() {
+  %x = "testvar.single_result"() : () -> i32
+  // CHECK: %{{.*}} = "testvar.single_result"() : () -> i32
+  return
+}
+
+// -----
+
+// Test an operation with a single result definition and a wrong number of results.
+func.func @testSingleResultFail() {
+  // expected-error@+1 {{op expects exactly 1 results, but got 2}}
+  %x, %y = "testvar.single_result"() : () -> (i32, i32)  
+  return
+}
+
+// -----
+
+// Test an operation with a single result definition and a wrong number of results.
+func.func @testSingleResultFail() {
+  // expected-error@+1 {{op expects exactly 1 results, but got 0}}
+  "testvar.single_result"() : () -> ()  
+  return
+}
+
+// -----
+
+
+//===----------------------------------------------------------------------===//
+// Variadic result
+//===----------------------------------------------------------------------===//
+
+
+// Test an operation with a single variadic result.
+func.func @testVarResult() {
+  "testvar.var_result"() : () -> (i16, i64)
+  // CHECK: "testvar.var_result"() : () -> (i16, i64)
+  "testvar.var_result"() : () -> (i16, i32, i64)
+  // CHECK-NEXT: "testvar.var_result"() : () -> (i16, i32, i64)
+  "testvar.var_result"() : () -> (i16, i32, i32, i64)
+  // CHECK-NEXT: "testvar.var_result"() : () -> (i16, i32, i32, i64)
+  "testvar.var_result"() : () -> (i16, i32, i32, i32, i64)
+  // CHECK-NEXT: "testvar.var_result"() : () -> (i16, i32, i32, i32, i64)
+  return
+}
+
+// -----
+
+// Check that the verifier of a variadic result  fails if the variadic is given
+// a wrong type.
+func.func @testVarResultFail() {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.var_result"() : () -> (i16, i64, i64)
+  return
+}
+
+// -----
+
+// Check that the verifier of a variadic result fails if the variadic is given
+// a wrong type on the second value.
+func.func @testVarResultFail() {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.var_result"() : () -> (i16, i32, i64, i64)
+  return
+}
+
+// -----
+
+// Check that if we do not give enough results, the verifier fails.
+func.func @testVarResultFail() {
+  // expected-error@+1 {{op expects at least 2 results, but got 0}}
+  "testvar.var_result"() : () -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Optional result
+//===----------------------------------------------------------------------===//
+
+
+// Test an operation with a single optional result.
+func.func @testOptResult() {
+  "testvar.opt_result"() : () -> (i16, i64)
+  // CHECK: "testvar.opt_result"() : () -> (i16, i64)
+  "testvar.opt_result"() : () -> (i16, i32, i64)
+  // CHECK-NEXT: "testvar.opt_result"() : () -> (i16, i32, i64)
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional result fails if the variadic is
+// given a wrong type.
+func.func @testOptResultFail() {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testvar.opt_result"() : () -> (i16, i64, i64)
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional result fails if there are too
+// many results.
+func.func @testOptResultFail() {
+  // expected-error@+1 {{op expects at most 3 results, but got 4}}
+  "testvar.opt_result"() : () -> (i16, i32, i32, i64)
+  return
+}
+
+// -----
+
+// Check that the verifier of an optional result fails if there are not
+// enough results.
+func.func @testOptResultFail() {
+  // expected-error@+1 {{op expects at least 2 results, but got 1}}
+  "testvar.opt_result"() : () -> (i16)
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Multiple variadic
+//===----------------------------------------------------------------------===//
+
+// Check that an operation with multiple variadics expects the segment size
+// attribute
+func.func @testMultResultsMissingSegment() {
+  // expected-error@+1 {{'result_segment_sizes' attribute is expected but not provided}}
+  "testvar.var_and_opt_result"() : () -> (i16, i16, i64)
+  return
+}
+
+// -----
+
+// Check that an operation with multiple variadics expects the segment size
+// attribute of the right type
+func.func @testMultResultsWrongSegmentType() {
+  // expected-error@+1 {{'result_segment_sizes' attribute is expected to be a dense i32 array}}
+  "testvar.var_and_opt_result"() {result_segment_sizes = i32} : () -> (i16, i16, i64)
+  return
+}
+
+// -----
+
+// Check that an operation with multiple variadics with the right segment size
+// verifies.
+func.func @testMultResults() {
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 2, 0, 1>} : () -> (i16, i16, i64)
+  // CHECK: "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 2, 0, 1>} : () -> (i16, i16, i64)
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 2, 1, 1>} : () -> (i16, i16, i32, i64)
+  // CHECK-NEXT: "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 2, 1, 1>} : () -> (i16, i16, i32, i64)
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 0, 1, 1>} : () -> (i32, i64)
+  // CHECK-NEXT: "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 0, 1, 1>} : () -> (i32, i64)
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects non-negative values
+func.func @testMultResultsSegmentNegative() {
+  // expected-error@+1 {{'result_segment_sizes' attribute for specifying result segments must have non-negative values}}
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 2, -1, 1>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects 1 for single values
+func.func @testMultResultsSegmentWrongSingle() {
+  // expected-error@+1 {{element 2 in 'result_segment_sizes' attribute must be equal to 1}}
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 0, 0, 0>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the segment sizes expects not more than 1 for optional values
+func.func @testMultResultsSegmentWrongOptional() {
+  // expected-error@+1 {{element 1 in 'result_segment_sizes' attribute must be equal to 0 or 1}}
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 0, 2, 0>} : () -> ()
+  return
+}
+
+// -----
+
+// Check that the sum of the segment sizes should be equal to the number of results
+func.func @testMultResultsSegmentWrongOptional() {
+  // expected-error@+1 {{sum of elements in 'result_segment_sizes' attribute must be equal to the number of results}}
+  "testvar.var_and_opt_result"() {result_segment_sizes = array<i32: 0, 0, 1>} : () -> (i32, i64)
+  return
+}