[mlir][ODS] Add a new trait `TypesMatchWith`

[rriddle]

Summary

This trait takes three arguments: lhs, rhs, transformer. It verifies that the type of 'rhs' matches the type of 'lhs' when the given 'transformer' is applied to 'lhs'. This allows for adding constraints like: "the type of 'a' must match the element type of 'b'". A followup revision will add support in the declarative parser for using these equality constraints to port more c++ parsers to the declarative form.

Depends On D74646

[rriddle]

@antiagainst @jpienaar I'm not attached to the name here, I just couldn't think of one so please suggest something better if you can.

[rriddle]

Rebase

[jpienaar]

Just brief scan :)

mlir/include/mlir/IR/OpBase.td

1721

Could we do something like:

that denotes that transformer(lhs) == rhs ?

(makes it clear where transformer is applied, simpler to read :))

[rriddle]

Resolve comments

[stephenneuendorffer]

mlir/include/mlir/Dialect/StandardOps/Ops.td

374

I can't parse this. suggest: result type has i1 element type and same shape as operands

442

I can't parse this...

1056

I can't parse this...

1073–1077

Unrelated change? Why does this need to be IntegerOrFloatLike?

1227

This is similar to other comments but "value type" starts to be ambiguous in a message. maybe "type of value operand matches element type of memref operand" instead?
or "type of 'value' matches element type of 'memref'"

1492

Ditto

1528

Ditto

[rriddle]

Resolve comments.

[rriddle]

mlir/include/mlir/Dialect/StandardOps/Ops.td

1073–1077

Not unrelated, getI1SameShape asserts that the given type is integer-or-float like. This avoids that assert.

[antiagainst]

LGTM!

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1107

Give it a more descriptive name like checkAttrSizedValueSegmentsCode or something? (Sorry my bad previously using just code. :))

[stephenneuendorffer]

mlir/include/mlir/Dialect/StandardOps/Ops.td

1073–1077

It seems like this is an unnecessary condition for 'select' which used to be type generic...

[rriddle]

mlir/include/mlir/Dialect/StandardOps/Ops.td

1073–1077

It was never truly type generic, it was just never verified.

[stephenneuendorffer]

Um... OK. It's not clear to me *why* select shouldn't type generic, but we can cross that bridge later, I guess :)

[rriddle]

In D74647#1881808, @stephenneuendorffer wrote:

Um... OK. It's not clear to me *why* select shouldn't type generic, but we can cross that bridge later, I guess :)

I'm not disagreeing with you :)

[rriddle]

Resolve comments.

[jpienaar]

Nice, thanks!

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1155

Would front() work here?

[rriddle]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1155

Not yet, I need to add more accessors to the indexed_range class.

mlir/include/mlir/Dialect/StandardOps/Ops.td

let extraClassDeclaration = [{
     }
   }];
 
   let assemblyFormat = [{
     $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
   }];
 }
 
-def CallIndirectOp : Std_Op<"call_indirect", [CallOpInterface]> {
+def CallIndirectOp : Std_Op<"call_indirect", [
+      CallOpInterface,
+      TypesMatchWith<"callee input types match argument types",
+                     "callee", "operands",
+                     "$_self.cast<FunctionType>().getInputs()">,
+      TypesMatchWith<"callee result types match result types",
+                     "callee", "results",
+                     "$_self.cast<FunctionType>().getResults()">
+    ]> {
   let summary = "indirect call operation";
   let description = [{
     The "call_indirect" operation represents an indirect call to a value of
     function type.  Functions are first class types in MLIR, and may be passed
     as arguments and merged together with block arguments.  The operands
     and result types of the call must match the specified function type.
 
       %3 = call_indirect %2(%0, %1) : (f32, f32) -> f32
   }];
 
   let arguments = (ins FunctionType:$callee, Variadic<AnyType>:$operands);
-  let results = (outs Variadic<AnyType>);
+  let results = (outs Variadic<AnyType>:$results);
 
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value callee,"
     "ValueRange operands = {}", [{
       result.operands.push_back(callee);
       result.addOperands(operands);
       result.addTypes(callee.getType().cast<FunctionType>().getResults());
   }]>];
 
   let extraClassDeclaration = [{
     Value getCallee() { return getOperand(0); }
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
 
     operand_iterator arg_operand_begin() { return ++operand_begin(); }
     operand_iterator arg_operand_end() { return operand_end(); }
 
     /// Return the callee of this operation.
     CallInterfaceCallable getCallableForCallee() { return getCallee(); }
   }];
 
+  let verifier = ?;
   let hasCanonicalizer = 1;
 }
 
 def CeilFOp : FloatUnaryOp<"ceilf"> {
   let summary = "ceiling of the specified value";
   let description = [{
     The `ceilf` operation computes the ceiling of a given value. It takes one
     operand and returns one result of the same type. This type may be a float
     scalar type, a vector whose element type is float, or a tensor of floats.
     It has no standard attributes.
   }];
 }
 
 def CmpFOp : Std_Op<"cmpf",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape,
+     TypesMatchWith<
+       "result type has i1 element type and same shape as operands",
+       "lhs", "result", "getI1SameShape($_self)">]> {
   let summary = "floating-point comparison operation";
   let description = [{
     The "cmpf" operation compares its two operands according to the float
     comparison rules and the predicate specified by the respective attribute.
     The predicate defines the type of comparison: (un)orderedness, (in)equality
     and signed less/greater than (or equal to) as well as predicates that are
     always true or false.  The operands must have the same type, and this type
     must be a float type, or a vector or tensor thereof.  The result is an i1,
     or a vector/tensor thereof having the same shape as the inputs. Unlike cmpi,
     the operands are always treated as signed. The u prefix indicates
     *unordered* comparison, not unsigned comparison, so "une" means unordered or
     not equal. For the sake of readability by humans, custom assembly form for
     the operation uses a string-typed attribute for the predicate.  The value of
     this attribute corresponds to lower-cased name of the predicate constant,
     e.g., "one" means "ordered not equal".  The string representation of the
     attribute is merely a syntactic sugar and is converted to an integer
     attribute by the parser.
 
       %r1 = cmpf "oeq" %0, %1 : f32
       %r2 = cmpf "ult" %0, %1 : tensor<42x42xf64>
       %r3 = "std.cmpf"(%0, %1) {predicate: 0} : (f8, f8) -> i1
   }];
 
   let arguments = (ins FloatLike:$lhs, FloatLike:$rhs);
-  let results = (outs BoolLike);
+  let results = (outs BoolLike:$result);
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpFPredicate predicate,"
     "Value lhs, Value rhs", [{
       ::buildCmpFOp(builder, result, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{

 def CmpIPredicateAttr : I64EnumAttr<
     "CmpIPredicate", "",
     [CMPI_P_EQ, CMPI_P_NE, CMPI_P_SLT, CMPI_P_SLE, CMPI_P_SGT,
      CMPI_P_SGE, CMPI_P_ULT, CMPI_P_ULE, CMPI_P_UGT, CMPI_P_UGE]> {
   let cppNamespace = "::mlir";
 }
 
 def CmpIOp : Std_Op<"cmpi",
-    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
+    [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape,
+     TypesMatchWith<
+       "result type has i1 element type and same shape as operands",
+       "lhs", "result", "getI1SameShape($_self)">]> {
   let summary = "integer comparison operation";
   let description = [{
     The "cmpi" operation compares its two operands according to the integer
     comparison rules and the predicate specified by the respective attribute.
     The predicate defines the type of comparison: (in)equality, (un)signed
     less/greater than (or equal to).  The operands must have the same type, and
     this type must be an integer type, a vector or a tensor thereof.  The result
     is an i1, or a vector/tensor thereof having the same shape as the inputs.
to an integer attribute by the parser.
       %r3 = "std.cmpi"(%0, %1){predicate: 0} : (i8, i8) -> i1
   }];
 
   let arguments = (ins
       CmpIPredicateAttr:$predicate,
       IntegerLike:$lhs,
       IntegerLike:$rhs
   );
-  let results = (outs BoolLike);
+  let results = (outs BoolLike:$result);
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, CmpIPredicate predicate,"
     "Value lhs, Value rhs", [{
       ::buildCmpIOp(builder, result, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{
def UnsignedDivIOp : IntArithmeticOp<"divi_unsigned"> {
   let summary = "unsigned integer division operation";
   let hasFolder = 1;
 }
 
 def ExpOp : FloatUnaryOp<"exp"> {
   let summary = "base-e exponential of the specified value";
 }
 
-def ExtractElementOp : Std_Op<"extract_element", [NoSideEffect]> {
+def ExtractElementOp : Std_Op<"extract_element",
+    [NoSideEffect,
+     TypesMatchWith<"result type matches element type of aggregate",
+                    "aggregate", "result",
+                    "$_self.cast<ShapedType>().getElementType()">]> {
   let summary = "element extract operation";
   let description = [{
     The "extract_element" op reads a tensor or vector and returns one element
     from it specified by an index list. The output of extract is a new value
     with the same type as the elements of the tensor or vector. The arity of
     indices matches the rank of the accessed value (i.e., if a tensor is of rank
     3, then 3 indices are required for the extract).  The indices should all be
     of index type. For example:
 
       %3 = extract_element %0[%1, %2] : vector<4x4xi32>
   }];
 
   let arguments = (ins AnyTypeOf<[AnyVector, AnyTensor]>:$aggregate,
                        Variadic<Index>:$indices);
-  let results = (outs AnyType);
+  let results = (outs AnyType:$result);
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value aggregate,"
     "ValueRange indices = {}", [{
       auto resType = aggregate.getType().cast<ShapedType>()
                                          .getElementType();
       build(builder, result, resType, aggregate, indices);
     }]>];
let extraClassDeclaration = [{
     /// Return true if `a` and `b` are valid operand and result pairs for
     /// the operation.
     static bool areCastCompatible(Type a, Type b);
   }];
 
   let hasFolder = 0;
 }
 
-def LoadOp : Std_Op<"load"> {
+def LoadOp : Std_Op<"load",
+     [TypesMatchWith<"result type matches element type of 'memref'",
+                     "memref", "result",
+                     "$_self.cast<MemRefType>().getElementType()">]> {
   let summary = "load operation";
   let description = [{
     The "load" op reads an element from a memref specified by an index list. The
     output of load is a new value with the same type as the elements of the
     memref. The arity of indices is the rank of the memref (i.e., if the memref
     loaded from is of rank 3, then 3 indices are required for the load following
     the memref identifier). For example:
 
       %3 = load %0[%1, %1] : memref<4x4xi32>
   }];
 
   let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices);
-  let results = (outs AnyType);
+  let results = (outs AnyType:$result);
 
   let builders = [OpBuilder<
     "Builder *, OperationState &result, Value memref,"
     "ValueRange indices = {}", [{
       auto memrefType = memref.getType().cast<MemRefType>();
       result.addOperands(memref);
       result.addOperands(indices);
       result.types.push_back(memrefType.getElementType());
def ReturnOp : Std_Op<"return", [Terminator, HasParent<"FuncOp">]> {
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [OpBuilder<
     "Builder *b, OperationState &result", [{ build(b, result, llvm::None); }]
   >];
 }
 
-def SelectOp : Std_Op<"select", [NoSideEffect, SameOperandsAndResultShape]> {
+def SelectOp : Std_Op<"select", [NoSideEffect, SameOperandsAndResultShape,
+     AllTypesMatch<["true_value", "false_value", "result"]>,
+     TypesMatchWith<"condition type matches i1 equivalent of result type",
+                     "result", "condition",
+                     "getI1SameShape($_self)">]> {
   let summary = "select operation";
   let description = [{
     The "select" operation chooses one value based on a binary condition
     supplied as its first operand. If the value of the first operand is 1, the
     second operand is chosen, otherwise the third operand is chosen. The second
     and the third operand must have the same type. The operation applies
     elementwise to vectors and tensors.  The shape of all arguments must be
     identical. For example, the maximum operation is obtained by combining
     "select" with "cmpi" as follows.
 
       %2 = cmpi "gt" %0, %1 : i32         // %2 is i1
       %3 = select %2, %0, %1 : i32
   }];
 
-  let arguments = (ins BoolLike:$condition, AnyType:$true_value,
-                       AnyType:$false_value);
-  let results = (outs AnyType);
+  let arguments = (ins BoolLike:$condition, IntegerOrFloatLike:$true_value,
+                       IntegerOrFloatLike:$false_value);
+  let results = (outs IntegerOrFloatLike:$result);
+  let verifier = ?;
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value condition,"
     "Value trueValue, Value falseValue", [{
       result.addOperands({condition, trueValue, falseValue});
       result.addTypes(trueValue.getType());
   }]>];
 
   let extraClassDeclaration = [{
let extraClassDeclaration = [{
     /// Return true if `a` and `b` are valid operand and result pairs for
     /// the operation.
     static bool areCastCompatible(Type a, Type b);
   }];
 
   let hasFolder = 0;
 }
 
-def SplatOp : Std_Op<"splat", [NoSideEffect]> {
+def SplatOp : Std_Op<"splat", [NoSideEffect,
+     TypesMatchWith<"operand type matches element type of result",
+                    "aggregate", "input",
+                    "$_self.cast<ShapedType>().getElementType()">]> {
   let summary = "splat or broadcast operation";
   let description = [{
     The "splat" op reads a value of integer or float type and broadcasts it into
     a vector or a tensor. The output of splat is thus a new value of either
     vector or tensor type with elemental type being its operand's type.
     When the result is a tensor, it has to be statically shaped.
 
       %1 = splat %0 : vector<8xi32>
def SplatOp : Std_Op<"splat", [NoSideEffect,
   let builders =
       [OpBuilder<"Builder *builder, OperationState &result, Value element, "
                   "Type aggregateType",
                   [{ build(builder, result, aggregateType, element); }]>];
 
   let hasFolder = 1;
 }
 
-def StoreOp : Std_Op<"store"> {
+def StoreOp : Std_Op<"store",
+     [TypesMatchWith<"type of 'value' matches element type of 'memref'",
+                     "memref", "value",
+                     "$_self.cast<MemRefType>().getElementType()">]> {
   let summary = "store operation";
   let description = [{
     The "store" op writes an element to a memref specified by an index list.
     The arity of indices is the rank of the memref (i.e. if the memref being
     stored to is of rank 3, then 3 indices are required for the store following
     the memref identifier). The store operation does not produce a result.
 
     In the following example, the ssa value '%v' is stored in memref '%A' at
let extraClassDeclaration = [{
     static bool areCastCompatible(Type a, Type b);
 
     /// The result of a tensor_cast is always a tensor.
     TensorType getType() { return getResult().getType().cast<TensorType>(); }
   }];
 }
 
 def TensorLoadOp : Std_Op<"tensor_load",
-    [SameOperandsAndResultShape, SameOperandsAndResultElementType]> {
+    [SameOperandsAndResultShape, SameOperandsAndResultElementType,
+     TypesMatchWith<"result type matches tensor equivalent of 'memref'",
+                    "memref", "result",
+                    "getTensorTypeFromMemRefType($_self)">]> {
   let summary = "tensor load operation";
   let description = [{
     The "tensor_load" operation creates a tensor from a memref, making an
     independent copy of the element data. The result value is a tensor whose
     shape and element type match the memref operand.
 
     Produce a value of tensor<4x?xf32> type.
        %12 = tensor_load %10 : memref<4x?xf32, #layout, memspace0>
   }];
 
-  let arguments = (ins AnyMemRef);
-  let results = (outs AnyTensor);
+  let arguments = (ins AnyMemRef:$memref);
+  let results = (outs AnyTensor:$result);
   // TensorLoadOp is fully verified by traits.
   let verifier = ?;
 
   let builders = [OpBuilder<
     "Builder *builder, OperationState &result, Value memref", [{
       auto memrefType = memref.getType().cast<MemRefType>();
       auto resultType = RankedTensorType::get(memrefType.getShape(),
                                               memrefType.getElementType());
       result.addOperands(memref);
       result.addTypes(resultType);
   }]>];
 
 
   let extraClassDeclaration = [{
     /// The result of a tensor_load is always a tensor.
     TensorType getType() { return getResult().getType().cast<TensorType>(); }
   }];
 }
 
 def TensorStoreOp : Std_Op<"tensor_store",
-    [SameOperandsShape, SameOperandsElementType]> {
+    [SameOperandsShape, SameOperandsElementType,
+     TypesMatchWith<"type of 'value' matches tensor equivalent of 'memref'",
+                    "memref", "tensor",
+                    "getTensorTypeFromMemRefType($_self)">]> {
   let summary = "tensor store operation";
   let description = [{
     The "tensor_store" operation stores the contents of a tensor into a memref.
     The first operand is a value of tensor type, the second operand is a value
     of memref type. The shapes and element types of these must match, and are
     specified by the memref type.
 
     Example:

mlir/include/mlir/Dialect/VectorOps/VectorOps.td

let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
 }
 
 def Vector_ExtractElementOp :
   Vector_Op<"extractelement", [NoSideEffect,
-     PredOpTrait<"operand and result have same element type",
-                 TCresVTEtIsSameAsOpBase<0, 0>>]>,
+     TypesMatchWith<"result type matches element type of vector operand",
+                    "vector", "result",
+                    "$_self.cast<ShapedType>().getElementType()">]>,
     Arguments<(ins AnyVector:$vector, AnyInteger:$position)>,
-    Results<(outs AnyType)> {
+    Results<(outs AnyType:$result)> {
   let summary = "extractelement operation";
   let description = [{
     Takes an 1-D vector and a dynamic index position and extracts the
     scalar at that position. Note that this instruction resembles
     vector.extract, but is restricted to 1-D vectors and relaxed
     to dynamic indices. It is meant to be closer to LLVM's version:
     https://llvm.org/docs/LangRef.html#extractelement-instruction
 
let builders = [OpBuilder<
     "build(b, result, lhs.getType(), lhs, rhs, acc);">];
   let extraClassDeclaration = [{
     VectorType getVectorType() { return lhs().getType().cast<VectorType>(); }
   }];
 }
 
 def Vector_InsertElementOp :
   Vector_Op<"insertelement", [NoSideEffect,
-     PredOpTrait<"source operand and result have same element type",
-                 TCresVTEtIsSameAsOpBase<0, 0>>,
-     PredOpTrait<"dest operand and result have same type",
-                 TCresIsSameAsOpBase<0, 1>>]>,
+     TypesMatchWith<"source operand type matches element type of result",
+                    "result", "source",
+                    "$_self.cast<ShapedType>().getElementType()">,
+     AllTypesMatch<["dest", "result"]>]>,
      Arguments<(ins AnyType:$source, AnyVector:$dest, AnyInteger:$position)>,
-     Results<(outs AnyVector)> {
+     Results<(outs AnyVector:$result)> {
   let summary = "insertelement operation";
   let description = [{
     Takes a scalar source, an 1-D destination vector and a dynamic index
     position and inserts the source into the destination at the proper
     position.  Note that this instruction resembles vector.insert, but
     is restricted to 1-D vectors and relaxed to dynamic indices. It is
     meant to be closer to LLVM's version:
     https://llvm.org/docs/LangRef.html#insertelement-instruction

mlir/include/mlir/IR/OpBase.td

def IntegerLike : TypeConstraint<Or<[AnyInteger.predicate, Index.predicate,
         VectorOf<[AnyInteger]>.predicate, TensorOf<[AnyInteger]>.predicate]>,
     "integer-like">;
 
 // Type constraint for float-like types: floats, vectors or tensors thereof.
 def FloatLike : TypeConstraint<Or<[AnyFloat.predicate,
         VectorOf<[AnyFloat]>.predicate, TensorOf<[AnyFloat]>.predicate]>,
     "floating-point-like">;
 
+// Type constraint for integer-like or float-like types.
+def IntegerOrFloatLike : TypeConstraint<Or<[IntegerLike.predicate,
+                                            FloatLike.predicate]>,
+    "integer-like or floating-point-like">;
+
 
 //===----------------------------------------------------------------------===//
 // Attribute definitions
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Base attribute definition
 
class AllRanksMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, Rank<"_self">.result, "rank">;
 
 class AllShapesMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, Shape<"_self">.result, "shape">;
 
 class AllTypesMatch<list<string> names> :
     AllMatchSameOperatorTrait<names, "$_self.getType()", "type">;
 
+// A type constraint that denotes `transform(lhs.getType()) == rhs.getType()`.
+class TypesMatchWith<string description, string lhsArg, string rhsArg,
+                     string transform> :
+    PredOpTrait<description, CPred<
+      !subst("$_self", "$" # lhsArg # ".getType()", transform)
+      # " == $" # rhsArg # ".getType()">> {
+  string lhs = lhsArg;
+  string rhs = rhsArg;
+  string transformer = transform;
+}
+
 // Type Constraint operand `idx`'s Element type is `type`.
 class TCopVTEtIs<int idx, Type type> : And<[
    CPred<"$_op.getNumOperands() > " # idx>,
    SubstLeaves<"$_self", "$_op.getOperand(" # idx # ").getType()",
      IsShapedTypePred>,
    SubstLeaves<"$_self", "getElementTypeOrSelf($_op.getOperand(" # idx # "))",
      type.predicate>]>;
 

mlir/include/mlir/IR/OperationSupport.h

: public llvm::iterator_range<
           ValueTypeIterator<typename ValueRangeT::iterator>> {
 public:
   using llvm::iterator_range<
       ValueTypeIterator<typename ValueRangeT::iterator>>::iterator_range;
   template <typename Container>
   ValueTypeRange(Container &&c) : ValueTypeRange(c.begin(), c.end()) {}
 };
 
+template <typename RangeT>
+inline bool operator==(ArrayRef<Type> lhs, const ValueTypeRange<RangeT> &rhs) {
+  return lhs.size() == llvm::size(rhs) &&
+         std::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
 //===----------------------------------------------------------------------===//
 // OperandRange
 
 /// This class implements the operand iterators for the Operation class.
 class OperandRange final
     : public detail::indexed_accessor_range_base<OperandRange, OpOperand *,
                                                  Value, Value, Value> {
 public:
   using RangeBaseT::RangeBaseT;
   OperandRange(Operation *op);
 
   /// Returns the types of the values within this range.
   using type_iterator = ValueTypeIterator<iterator>;
   using type_range = ValueTypeRange<OperandRange>;
   type_range getTypes() const { return {begin(), end()}; }
+  auto getType() const { return getTypes(); }
 
 private:
   /// See `detail::indexed_accessor_range_base` for details.
   static OpOperand *offset_base(OpOperand *object, ptrdiff_t index) {
     return object + index;
   }
   /// See `detail::indexed_accessor_range_base` for details.
   static Value dereference_iterator(OpOperand *object, ptrdiff_t index) {
public:
   using indexed_accessor_range<ResultRange, Operation *, OpResult, OpResult,
                                OpResult>::indexed_accessor_range;
   ResultRange(Operation *op);
 
   /// Returns the types of the values within this range.
   using type_iterator = ArrayRef<Type>::iterator;
   using type_range = ArrayRef<Type>;
   type_range getTypes() const;
+  auto getType() const { return getTypes(); }
 
 private:
   /// See `indexed_accessor_range` for details.
   static OpResult dereference(Operation *op, ptrdiff_t index);
 
   /// Allow access to `dereference_iterator`.
   friend indexed_accessor_range<ResultRange, Operation *, OpResult, OpResult,
                                 OpResult>;
public:
   ValueRange(ArrayRef<Value> values = llvm::None);
   ValueRange(OperandRange values);
   ValueRange(ResultRange values);
 
   /// Returns the types of the values within this range.
   using type_iterator = ValueTypeIterator<iterator>;
   using type_range = ValueTypeRange<ValueRange>;
   type_range getTypes() const { return {begin(), end()}; }
+  auto getType() const { return getTypes(); }
 
 private:
   using OwnerT = detail::ValueRangeOwner;
 
   /// See `detail::indexed_accessor_range_base` for details.
   static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
   /// See `detail::indexed_accessor_range_base` for details.
   static Value dereference_iterator(const OwnerT &owner, ptrdiff_t index);

mlir/include/mlir/Support/STLExtras.h

public:
 
   iterator begin() const { return iterator(base, 0); }
   iterator end() const { return iterator(base, count); }
   ReferenceT operator[](unsigned index) const {
     assert(index < size() && "invalid index for value range");
     return DerivedT::dereference_iterator(base, index);
   }
 
+  /// Compare this range with another.
+  template <typename OtherT> bool operator==(const OtherT &other) {
+    return size() == llvm::size(other) &&
+           std::equal(begin(), end(), other.begin());
+  }
+
   /// Return the size of this range.
   size_t size() const { return count; }
 
   /// Return if the range is empty.
   bool empty() const { return size() == 0; }
 
   /// Drop the first N elements, and keep M elements.
   DerivedT slice(size_t n, size_t m) const {

mlir/lib/Dialect/StandardOps/Ops.cpp

 }
 
 static void print(OpAsmPrinter &p, CallIndirectOp op) {
   p << "call_indirect " << op.getCallee() << '(' << op.getArgOperands() << ')';
   p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"callee"});
   p << " : " << op.getCallee().getType();
 }
 
-static LogicalResult verify(CallIndirectOp op) {
-  // The callee must be a function.
-  auto fnType = op.getCallee().getType().dyn_cast<FunctionType>();
-  if (!fnType)
-    return op.emitOpError("callee must have function type");
-
-  // Verify that the operand and result types match the callee.
-  if (fnType.getNumInputs() != op.getNumOperands() - 1)
-    return op.emitOpError("incorrect number of operands for callee");
-
-  for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i)
-    if (op.getOperand(i + 1).getType() != fnType.getInput(i))
-      return op.emitOpError("operand type mismatch");
-
-  if (fnType.getNumResults() != op.getNumResults())
-    return op.emitOpError("incorrect number of results for callee");
-
-  for (unsigned i = 0, e = fnType.getNumResults(); i != e; ++i)
-    if (op.getResult(i).getType() != fnType.getResult(i))
-      return op.emitOpError("result type mismatch");
-
-  return success();
-}
-
 void CallIndirectOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<SimplifyIndirectCallWithKnownCallee>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // General helpers for comparison ops
 //===----------------------------------------------------------------------===//
 
 // Return the type of the same shape (scalar, vector or tensor) containing i1.
-static Type getCheckedI1SameShape(Builder *build, Type type) {
-  auto i1Type = build->getI1Type();
+static Type getCheckedI1SameShape(Type type) {
+  auto i1Type = IntegerType::get(1, type.getContext());
   if (type.isIntOrIndexOrFloat())
     return i1Type;
   if (auto tensorType = type.dyn_cast<RankedTensorType>())
     return RankedTensorType::get(tensorType.getShape(), i1Type);
   if (type.isa<UnrankedTensorType>())
     return UnrankedTensorType::get(i1Type);
   if (auto vectorType = type.dyn_cast<VectorType>())
     return VectorType::get(vectorType.getShape(), i1Type);
   return Type();
 }
 
-static Type getI1SameShape(Builder *build, Type type) {
-  Type res = getCheckedI1SameShape(build, type);
+static Type getI1SameShape(Type type) {
+  Type res = getCheckedI1SameShape(type);
   assert(res && "expected type with valid i1 shape");
   return res;
 }
 
 //===----------------------------------------------------------------------===//
 // CmpIOp
 //===----------------------------------------------------------------------===//
 
 static void buildCmpIOp(Builder *build, OperationState &result,
                         CmpIPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
-  result.types.push_back(getI1SameShape(build, lhs.getType()));
+  result.types.push_back(getI1SameShape(lhs.getType()));
   result.addAttribute(
       CmpIOp::getPredicateAttrName(),
       build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
 static ParseResult parseCmpIOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> ops;
   SmallVector<NamedAttribute, 4> attrs;
static ParseResult parseCmpIOp(OpAsmParser &parser, OperationState &result) {
   // Rewrite string attribute to an enum value.
   StringRef predicateName = predicateNameAttr.cast<StringAttr>().getValue();
   Optional<CmpIPredicate> predicate = symbolizeCmpIPredicate(predicateName);
   if (!predicate.hasValue())
     return parser.emitError(parser.getNameLoc())
            << "unknown comparison predicate \"" << predicateName << "\"";
 
   auto builder = parser.getBuilder();
-  Type i1Type = getCheckedI1SameShape(&builder, type);
+  Type i1Type = getCheckedI1SameShape(type);
   if (!i1Type)
     return parser.emitError(parser.getNameLoc(),
                             "expected type with valid i1 shape");
 
   attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(*predicate));
   result.attributes = attrs;
 
   result.addTypes({i1Type});
return llvm::StringSwitch<CmpFPredicate>(name)
       .Case("uno", CmpFPredicate::UNO)
       .Case("true", CmpFPredicate::AlwaysTrue)
       .Default(CmpFPredicate::NumPredicates);
 }
 
 static void buildCmpFOp(Builder *build, OperationState &result,
                         CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
-  result.types.push_back(getI1SameShape(build, lhs.getType()));
+  result.types.push_back(getI1SameShape(lhs.getType()));
   result.addAttribute(
       CmpFOp::getPredicateAttrName(),
       build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
 static ParseResult parseCmpFOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> ops;
   SmallVector<NamedAttribute, 4> attrs;
static ParseResult parseCmpFOp(OpAsmParser &parser, OperationState &result) {
   StringRef predicateName = predicateNameAttr.cast<StringAttr>().getValue();
   auto predicate = CmpFOp::getPredicateByName(predicateName);
   if (predicate == CmpFPredicate::NumPredicates)
     return parser.emitError(parser.getNameLoc(),
                             "unknown comparison predicate \"" + predicateName +
                                 "\"");
 
   auto builder = parser.getBuilder();
-  Type i1Type = getCheckedI1SameShape(&builder, type);
+  Type i1Type = getCheckedI1SameShape(type);
   if (!i1Type)
     return parser.emitError(parser.getNameLoc(),
                             "expected type with valid i1 shape");
 
   attrs[0].second = builder.getI64IntegerAttr(static_cast<int64_t>(predicate));
   result.attributes = attrs;
 
   result.addTypes({i1Type});
return failure(
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(aggregateInfo, type, result.operands) ||
       parser.resolveOperands(indexInfo, indexTy, result.operands) ||
       parser.addTypeToList(type.getElementType(), result.types));
 }
 
 static LogicalResult verify(ExtractElementOp op) {
-  auto aggregateType = op.getAggregate().getType().cast<ShapedType>();
-
-  // This should be possible with tablegen type constraints
-  if (op.getType() != aggregateType.getElementType())
-    return op.emitOpError("result type must match element type of aggregate");
-
   // Verify the # indices match if we have a ranked type.
+  auto aggregateType = op.getAggregate().getType().cast<ShapedType>();
   if (aggregateType.hasRank() &&
       aggregateType.getRank() != op.getNumOperands() - 1)
     return op.emitOpError("incorrect number of indices for extract_element");
 
   return success();
 }
 
 OpFoldResult ExtractElementOp::fold(ArrayRef<Attribute> operands) {
return failure(
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(memrefInfo, type, result.operands) ||
       parser.resolveOperands(indexInfo, indexTy, result.operands) ||
       parser.addTypeToList(type.getElementType(), result.types));
 }
 
 static LogicalResult verify(LoadOp op) {
-  if (op.getType() != op.getMemRefType().getElementType())
-    return op.emitOpError("result type must match element type of memref");
-
   if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
     return op.emitOpError("incorrect number of indices for load");
-
   return success();
 }
 
 OpFoldResult LoadOp::fold(ArrayRef<Attribute> cstOperands) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
static ParseResult parseSelectOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 3> ops;
   SmallVector<NamedAttribute, 4> attrs;
   Type type;
   if (parser.parseOperandList(ops, 3) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type))
     return failure();
 
-  auto i1Type = getCheckedI1SameShape(&parser.getBuilder(), type);
+  auto i1Type = getCheckedI1SameShape(type);
   if (!i1Type)
     return parser.emitError(parser.getNameLoc(),
                             "expected type with valid i1 shape");
 
   SmallVector<Type, 3> types = {i1Type, type, type};
   return failure(parser.resolveOperands(ops, types, parser.getNameLoc(),
                                         result.operands) ||
                  parser.addTypeToList(type, result.types));
 }
 
 static void print(OpAsmPrinter &p, SelectOp op) {
   p << "select " << op.getOperands() << " : " << op.getTrueValue().getType();
   p.printOptionalAttrDict(op.getAttrs());
 }
 
-static LogicalResult verify(SelectOp op) {
-  auto trueType = op.getTrueValue().getType();
-  auto falseType = op.getFalseValue().getType();
-
-  if (trueType != falseType)
-    return op.emitOpError(
-        "requires 'true' and 'false' arguments to be of the same type");
-
-  return success();
-}
-
 OpFoldResult SelectOp::fold(ArrayRef<Attribute> operands) {
   auto condition = getCondition();
 
   // select true, %0, %1 => %0
   if (matchPattern(condition, m_One()))
     return getTrueValue();
 
   // select false, %0, %1 => %1
return failure(
       parser.parseColonType(memrefType) ||
       parser.resolveOperand(storeValueInfo, memrefType.getElementType(),
                             result.operands) ||
       parser.resolveOperand(memrefInfo, memrefType, result.operands) ||
       parser.resolveOperands(indexInfo, indexTy, result.operands));
 }
 
 static LogicalResult verify(StoreOp op) {
-  // First operand must have same type as memref element type.
-  if (op.getValueToStore().getType() != op.getMemRefType().getElementType())
-    return op.emitOpError(
-        "first operand must have same type memref element type");
-
   if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
     return op.emitOpError("store index operand count not equal to memref rank");
 
   return success();
 }
 
 LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
                             SmallVectorImpl<OpFoldResult> &results) {

 OpFoldResult TensorCastOp::fold(ArrayRef<Attribute> operands) {
   return impl::foldCastOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // Helpers for Tensor[Load|Store]Op
 //===----------------------------------------------------------------------===//
 
-static Type getTensorTypeFromMemRefType(Builder &b, Type type) {
+static Type getTensorTypeFromMemRefType(Type type) {
   if (auto memref = type.dyn_cast<MemRefType>())
     return RankedTensorType::get(memref.getShape(), memref.getElementType());
-  return b.getNoneType();
+  return NoneType::get(type.getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // TensorLoadOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, TensorLoadOp op) {
   p << "tensor_load " << op.getOperand();
   p.printOptionalAttrDict(op.getAttrs());
   p << " : " << op.getOperand().getType();
 }
 
 static ParseResult parseTensorLoadOp(OpAsmParser &parser,
                                      OperationState &result) {
   OpAsmParser::OperandType op;
   Type type;
-  return failure(parser.parseOperand(op) ||
-                 parser.parseOptionalAttrDict(result.attributes) ||
-                 parser.parseColonType(type) ||
-                 parser.resolveOperand(op, type, result.operands) ||
-                 parser.addTypeToList(
-                     getTensorTypeFromMemRefType(parser.getBuilder(), type),
-                     result.types));
+  return failure(
+      parser.parseOperand(op) ||
+      parser.addTypeToList(getTensorTypeFromMemRefType(type), result.types));
 }
 
 //===----------------------------------------------------------------------===//
 // TensorStoreOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, TensorStoreOp op) {
   p << "tensor_store " << op.tensor() << ", " << op.memref();
   p.printOptionalAttrDict(op.getAttrs());
   p << " : " << op.memref().getType();
 }
 
 static ParseResult parseTensorStoreOp(OpAsmParser &parser,
                                       OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> ops;
   Type type;
   llvm::SMLoc loc = parser.getCurrentLocation();
   return failure(
       parser.parseOperandList(ops, /*requiredOperandCount=*/2) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
-      parser.resolveOperands(
-          ops, {getTensorTypeFromMemRefType(parser.getBuilder(), type), type},
+      parser.resolveOperands(ops, {getTensorTypeFromMemRefType(type), type},
                              loc, result.operands));
 }
 
 //===----------------------------------------------------------------------===//
 // TruncateIOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TruncateIOp op) {
   auto srcType = getElementTypeOrSelf(op.getOperand().getType());

mlir/test/Dialect/VectorOps/invalid.mlir

func @insert_element(%arg0: f32, %arg1: vector<4x4xf32>) {
   %c = constant 3 : i32
   // expected-error@+1 {{'vector.insertelement' op expected 1-D vector}}
   %0 = vector.insertelement %arg0, %arg1[%c : i32] : vector<4x4xf32>
 }
 
 // -----
 
 func @insert_element_wrong_type(%arg0: i32, %arg1: vector<4xf32>) {
-  %c = constant 3 : index
-  // expected-error@+1 {{'vector.insertelement' op failed to verify that source operand and result have same element type}}
-  %0 = "vector.insertelement" (%arg0, %arg1, %c) : (i32, vector<4xf32>, index) -> (vector<4xf32>)
+  %c = constant 3 : i32
+  // expected-error@+1 {{'vector.insertelement' op failed to verify that source operand type matches element type of result}}
+  %0 = "vector.insertelement" (%arg0, %arg1, %c) : (i32, vector<4xf32>, i32) -> (vector<4xf32>)
 }
 
 // -----
 
 func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) {
   // expected-error@+1 {{expected non-empty position attribute}}
   %1 = vector.insert %a, %b[] : f32 into vector<4x8x16xf32>
 }

mlir/test/IR/invalid-ops.mlir

^bb0(%cond : i32, %t : i32, %f : i32):
   // expected-error@+1 {{op operand #0 must be bool-like}}
   %r = "std.select"(%cond, %t, %f) : (i32, i32, i32) -> i32
 }
 
 // -----
 
 func @func_with_ops(i1, i32, i64) {
 ^bb0(%cond : i1, %t : i32, %f : i64):
-  // expected-error@+1 {{'true' and 'false' arguments to be of the same type}}
+  // expected-error@+1 {{all of {true_value, false_value, result} have same type}}
   %r = "std.select"(%cond, %t, %f) : (i1, i32, i64) -> i32
 }
 
 // -----
 
 func @func_with_ops(i1, vector<42xi32>, vector<42xi32>) {
 ^bb0(%cond : i1, %t : vector<42xi32>, %f : vector<42xi32>):
   // expected-error@+1 {{requires the same shape for all operands and results}}
func @extract_element_invalid_index_type(%v : vector<3xf32>, %i : i32) {
   // expected-error@+1 {{operand #1 must be index}}
   %0 = "std.extract_element"(%v, %i) : (vector<3xf32>, i32) -> f32
   return
 }
 
 // -----
 
 func @extract_element_element_result_type_mismatch(%v : vector<3xf32>, %i : index) {
-  // expected-error@+1 {{result type must match element type of aggregate}}
+  // expected-error@+1 {{result type matches element type of aggregate}}
   %0 = "std.extract_element"(%v, %i) : (vector<3xf32>, index) -> f64
   return
 }
 
 // -----
 
 func @extract_element_vector_too_many_indices(%v : vector<3xf32>, %i : index) {
   // expected-error@+1 {{incorrect number of indices for extract_element}}

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 void OpEmitter::genVerifier() {
   auto valueInit = def.getValueInit("verifier");
   CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
   bool hasCustomVerify = codeInit && !codeInit->getValue().empty();
 
   auto &method = opClass.newMethod("LogicalResult", "verify", /*params=*/"");
   auto &body = method.body();
 
+  const char *checkAttrSizedValueSegmentsCode = R"(
+  auto sizeAttr = getAttrOfType<DenseIntElementsAttr>("{0}");
+  auto numElements = sizeAttr.getType().cast<ShapedType>().getNumElements();
+  if (numElements != {1}) {{
+    return emitOpError("'{0}' attribute for specifying {2} segments "
+                       "must have {1} elements");
+  }
+  )";
+
+  // Verify a few traits first so that we can use
+  // getODSOperands()/getODSResults() in the rest of the verifier.
+  for (auto &trait : op.getTraits()) {
+    if (auto *t = dyn_cast<tblgen::NativeOpTrait>(&trait)) {
+      if (t->getTrait() == "OpTrait::AttrSizedOperandSegments") {
+        body << formatv(checkAttrSizedValueSegmentsCode,
+                        "operand_segment_sizes", op.getNumOperands(),
+                        "operand");
+      } else if (t->getTrait() == "OpTrait::AttrSizedResultSegments") {
+        body << formatv(checkAttrSizedValueSegmentsCode, "result_segment_sizes",
+                        op.getNumResults(), "result");
+      }
+    }
+  }
+
   // Populate substitutions for attributes and named operands and results.
   for (const auto &namedAttr : op.getAttributes())
     verifyCtx.addSubst(namedAttr.name,
                        formatv("this->getAttr(\"{0}\")", namedAttr.name));
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     auto &value = op.getOperand(i);
-    // Skip from from first variadic operands for now. Else getOperand index
-    // used below doesn't match.
+    if (value.name.empty())
+      continue;
+
     if (value.isVariadic())
-      break;
-    if (!value.name.empty())
+      verifyCtx.addSubst(value.name, formatv("this->getODSOperands({0})", i));
+    else
       verifyCtx.addSubst(value.name,
-                         formatv("this->getOperation()->getOperand({0})", i));
+                         formatv("(*this->getODSOperands({0}).begin())", i));
   }
   for (int i = 0, e = op.getNumResults(); i < e; ++i) {
     auto &value = op.getResult(i);
-    // Skip from from first variadic results for now. Else getResult index used
-    // below doesn't match.
+    if (value.name.empty())
+      continue;
+
     if (value.isVariadic())
-      break;
-    if (!value.name.empty())
+      verifyCtx.addSubst(value.name, formatv("this->getODSResults({0})", i));
+    else
       verifyCtx.addSubst(value.name,
-                         formatv("this->getOperation()->getResult({0})", i));
+                         formatv("(*this->getODSResults({0}).begin())", i));
   }
 
   // Verify the attributes have the correct type.
   for (const auto &namedAttr : op.getAttributes()) {
     const auto &attr = namedAttr.attr;
     if (attr.isDerivedAttr())
       continue;
 
if (!attrPred.isNull()) {
           /*ctx=*/nullptr,
           tgfmt(attrPred.getCondition(), &verifyCtx.withSelf(varName)),
           attrName, attr.getDescription());
     }
 
     body << "  }\n";
   }
 
-  const char *code = R"(
-  auto sizeAttr = getAttrOfType<DenseIntElementsAttr>("{0}");
-  auto numElements = sizeAttr.getType().cast<ShapedType>().getNumElements();
-  if (numElements != {1}) {{
-    return emitOpError("'{0}' attribute for specifying {2} segments "
-                       "must have {1} elements");
-  }
-  )";
+  genOperandResultVerifier(body, op.getOperands(), "operand");
+  genOperandResultVerifier(body, op.getResults(), "result");
 
   for (auto &trait : op.getTraits()) {
     if (auto *t = dyn_cast<tblgen::PredOpTrait>(&trait)) {
       body << tgfmt("  if (!($0)) {\n    "
                     "return emitOpError(\"failed to verify that $1\");\n  }\n",
                     &verifyCtx, tgfmt(t->getPredTemplate(), &verifyCtx),
                     t->getDescription());
-    } else if (auto *t = dyn_cast<tblgen::NativeOpTrait>(&trait)) {
-      if (t->getTrait() == "OpTrait::AttrSizedOperandSegments") {
-        body << formatv(code, "operand_segment_sizes", op.getNumOperands(),
-                        "operand");
-      } else if (t->getTrait() == "OpTrait::AttrSizedResultSegments") {
-        body << formatv(code, "result_segment_sizes", op.getNumResults(),
-                        "result");
-      }
     }
   }
 
-  // These should happen after we verified the traits because
-  // getODSOperands()/getODSResults() may depend on traits (e.g.,
-  // AttrSizedOperandSegments/AttrSizedResultSegments).
-  genOperandResultVerifier(body, op.getOperands(), "operand");
-  genOperandResultVerifier(body, op.getResults(), "result");
-
   genRegionVerifier(body);
 
   if (hasCustomVerify) {
     FmtContext fctx;
     fctx.addSubst("cppClass", opClass.getClassName());
     auto printer = codeInit->getValue().ltrim().rtrim(" \t\v\f\r");
     body << "  " << tgfmt(printer, &fctx);
   } else {