[mlir][NFC] Update remaining dialect operations to use `hasVerifier` instead of `verifier`

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

Depends on D118828

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

def Arith_ConstantOp : Op<Arithmetic_Dialect, "constant",
   let arguments = (ins AnyAttr:$value);
   // TODO: Disallow arith.constant to return anything other than a signless
   // integer or float like. Downstream users of Arithmetic should only be
   // working with signless integers, floats, or vectors/tensors thereof.
   // However, it is necessary to allow arith.constant to return vectors/tensors
   // of strings and signed/unsigned integers (for now) as an artefact of
   // splitting the Standard dialect.
   let results = (outs /*SignlessIntegerOrFloatLike*/AnyType:$result);
-  let verifier = [{ return ::verify(*this); }];
 
   let builders = [
     OpBuilder<(ins "Attribute":$value),
     [{ build($_builder, $_state, value.getType(), value); }]>,
     OpBuilder<(ins "Attribute":$value, "Type":$type),
     [{ build($_builder, $_state, type, value); }]>,
   ];
 
   let extraClassDeclaration = [{
     /// Whether the constant op can be constructed with a particular value and
     /// type.
     static bool isBuildableWith(Attribute value, Type type);
   }];
 
   let hasFolder = 1;
   let assemblyFormat = "attr-dict $value";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_AddIOp : Arith_IntBinaryOp<"addi", [Commutative]> {
   let summary = "integer addition operation";
```mlir
       %3 = arith.constant 2 : i3      // %3 is 0b010
       %4 = arith.extui %3 : i3 to i6  // %4 is 0b000010
 
       %5 = arith.extui %0 : vector<2 x i32> to vector<2 x i64>
     ```
   }];
 
   let hasFolder = 1;
-  let verifier = [{ return verifyExtOp<IntegerType>(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExtSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_ExtSIOp : Arith_IToICastOp<"extsi"> {
   let summary = "integer sign extension operation";
let description = [{
     %4 = arith.extsi %3 : i3 to i6  // %4 is 0b000010
 
     %5 = arith.extsi %0 : vector<2 x i32> to vector<2 x i64>
     ```
   }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
-  let verifier = [{ return verifyExtOp<IntegerType>(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExtFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_ExtFOp : Arith_FToFCastOp<"extf"> {
   let summary = "cast from floating-point to wider floating-point";
   let description = [{
     Cast a floating-point value to a larger floating-point-typed value.
     The destination type must to be strictly wider than the source type.
     When operating on vectors, casts elementwise.
   }];
-
-  let verifier = [{ return verifyExtOp<FloatType>(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TruncIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_TruncIOp : Arith_IToICastOp<"trunci"> {
   let summary = "integer truncation operation";
```mlir
       %2 = arith.trunci %1 : i5 to i4 // %2 is 0b0101
       %3 = arith.trunci %1 : i5 to i3 // %3 is 0b101
 
       %5 = arith.trunci %0 : vector<2 x i32> to vector<2 x i16>
     ```
   }];
 
   let hasFolder = 1;
-  let verifier = [{ return verifyTruncateOp<IntegerType>(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TruncFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_TruncFOp : Arith_FToFCastOp<"truncf"> {
   let summary = "cast from floating-point to narrower floating-point";
   let description = [{
     Truncate a floating-point value to a smaller floating-point-typed value.
     The destination type must be strictly narrower than the source type.
     If the value cannot be exactly represented, it is rounded using the default
     rounding mode. When operating on vectors, casts elementwise.
   }];
 
   let hasFolder = 1;
-  let verifier = [{ return verifyTruncateOp<FloatType>(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // UIToFPOp
 //===----------------------------------------------------------------------===//
 
 def Arith_UIToFPOp : Arith_IToFCastOp<"uitofp"> {
   let summary = "cast from unsigned integer type to floating-point";

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

let arguments = (ins Variadic<Async_TokenType>:$dependencies,
                        Variadic<Async_AnyValueOrTokenType>:$operands);
 
   let results = (outs Async_TokenType:$token,
                       Variadic<Async_ValueType>:$results);
   let regions = (region SizedRegion<1>:$body);
 
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
-  let verifier = [{ return ::verify(*this); }];
 
   let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
   let builders = [
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$dependencies,
       "ValueRange":$operands,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>",
            "nullptr">:$bodyBuilder)>,
   ];
 
   let extraClassDeclaration = [{
Async_Op<"yield", [
       DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>]> {
   let summary = "terminator for Async execute operation";
   let description = [{
     The `async.yield` is a special terminator operation for the block inside
     `async.execute` operation.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
-
   let assemblyFormat = "($operands^ `:` type($operands))? attr-dict";
-
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def Async_AwaitOp : Async_Op<"await"> {
   let summary = "waits for the argument to become ready";
   let description = [{
     The `async.await` operation waits until the argument becomes ready, and for
     the `async.value` arguments it unwraps the underlying value
 
     Example:
 
     ```mlir
     %0 = ... : !async.token
     async.await %0 : !async.token
 
     %1 = ... : !async.value<f32>
     %2 = async.await %1 : !async.value<f32>
     ```
   }];
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
   let results = (outs Optional<AnyType>:$result);
 
   let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
 
   let builders = [
     OpBuilder<(ins "Value":$operand,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     Optional<Type> getResultType() {
       if (getResultTypes().empty()) return None;
       return getResultTypes()[0];
     }
   }];
 
   let assemblyFormat = [{
     $operand `:` custom<AwaitResultType>(
       type($operand), type($result)
     ) attr-dict
   }];
-
-  let verifier = [{ return ::verify(*this); }];
 }
 
 def Async_CreateGroupOp : Async_Op<"create_group", [NoSideEffect]> {
   let summary = "creates an empty async group";
   let description = [{
     The `async.create_group` allocates an empty async group. Async tokens or
     values can be added to this group later. The size of the group must be
     specified at construction time, and `await_all` operation will first

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

def Bufferization_CloneOp : Bufferization_Op<"clone", [
   let extraClassDeclaration = [{
     Value getSource() { return input(); }
     Value getTarget() { return output(); }
   }];
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 
   let hasFolder = 1;
-  let verifier = ?;
   let hasCanonicalizer = 1;
 }
 //===----------------------------------------------------------------------===//
 // ToTensorOp
 //===----------------------------------------------------------------------===//
 
 def Bufferization_ToTensorOp : Bufferization_Op<"to_tensor", [
     BufferizableOpInterface,
let description = [{
 
     If tensor load is used in the bufferization steps, mutating the source
     buffer after loading leads to undefined behavior.
   }];
 
   let arguments = (ins Arg<AnyRankedOrUnrankedMemRef,
                        "the reference to load from", [MemRead]>:$memref);
   let results = (outs AnyTensor:$result);
-  // MemrefToTensor is fully verified by traits.
-  let verifier = ?;
 
   let builders = [
     OpBuilder<(ins "Value":$memref), [{
       $_state.addOperands(memref);
       $_state.addTypes(memref::getTensorTypeFromMemRefType(memref.getType()));
     }]>];
 
   let extraClassDeclaration = [{
let description = [{
 
     This operation is a specialized variant of the built-in
     unrealized_conversion_cast and is intended for use in the context of
     gradual bufferization.
   }];
 
   let arguments = (ins AnyTensor:$tensor);
   let results = (outs AnyRankedOrUnrankedMemRef:$memref);
-  // This op is fully verified by traits.
-  let verifier = ?;
 
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // BufferizableOpInterface implementation
     //===------------------------------------------------------------------===//
 
     // Note: ToMemrefOp / ToTensorOp are temporary ops that are inserted at the
     // bufferization boundary. When One-Shot bufferization is complete, there

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

 // floating-point element type. These operations take two operands and return
 // one result, all of which must be complex numbers of the same type.
 class ComplexArithmeticOp<string mnemonic, list<Trait> traits = []> :
     Complex_Op<mnemonic, traits # [NoSideEffect, SameOperandsAndResultType,
     Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
   let results = (outs Complex<AnyFloat>:$result);
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($result)";
-  let verifier = ?;
 }
 
 // Base class for standard unary operations on complex numbers with a
 // floating-point element type. These operations take one operand and return
 // one result; the operand must be a complex number.
 class ComplexUnaryOp<string mnemonic, list<Trait> traits = []> :
     Complex_Op<mnemonic, traits # [NoSideEffect, Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$complex);
   let assemblyFormat = "$complex attr-dict `:` type($complex)";
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // AbsOp
 //===----------------------------------------------------------------------===//
 
 def AbsOp : ComplexUnaryOp<"abs",
     [TypesMatchWith<"complex element type matches result type",
let description = [{
     ```
   }];
 
   let arguments = (ins ArrayAttr:$value);
   let results = (outs Complex<AnyFloat>:$complex);
 
   let assemblyFormat = "$value attr-dict `:` type($complex)";
   let hasFolder = 1;
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
   
   let extraClassDeclaration = [{
     /// Returns true if a constant operation can be built with the given value
     /// and result type.
     static bool isBuildableWith(Attribute value, Type type);
   }];
 }
 

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for EmitC dialect ops.
 class EmitC_Op<string mnemonic, list<Trait> traits = []>
-    : Op<EmitC_Dialect, mnemonic, traits> {
-  let verifier = "return ::verify(*this);";
-}
+    : Op<EmitC_Dialect, mnemonic, traits>;
 
 def EmitC_ApplyOp : EmitC_Op<"apply", []> {
   let summary = "Apply operation";
   let description = [{
     With the `apply` operation the operators & (address of) and * (contents of)
     can be applied to a single operand.
 
     Example:
def EmitC_ApplyOp : EmitC_Op<"apply", []> {
   let arguments = (ins
     Arg<StrAttr, "the operator to apply">:$applicableOperator,
     AnyType:$operand
   );
   let results = (outs AnyType:$result);
   let assemblyFormat = [{
     $applicableOperator `(` $operand `)` attr-dict `:` functional-type($operand, results)
   }];
+  let hasVerifier = 1;
 }
 
 def EmitC_CallOp : EmitC_Op<"call", []> {
   let summary = "Call operation";
   let description = [{
     The `call` operation represents a C++ function call. The call allows
     specifying order of operands and attributes in the call as follows:
 
let arguments = (ins
     Arg<OptionalAttr<ArrayAttr>, "the order of operands and further attributes">:$args,
     Arg<OptionalAttr<ArrayAttr>, "template arguments">:$template_args,
     Variadic<AnyType>:$operands
   );
   let results = (outs Variadic<AnyType>);
   let assemblyFormat = [{
     $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
   }];
+  let hasVerifier = 1;
 }
 
 def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
   let summary = "Constant operation";
   let description = [{
     The `constant` operation produces an SSA value equal to some constant
     specified by an attribute. This can be used to form simple integer and
     floating point constants, as well as more exotic things like tensor
%1 = "emitc.constant"()
         : () -> !emitc.opaque<"int32_t*">
     ```
   }];
 
   let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType);
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def EmitC_IncludeOp
     : EmitC_Op<"include", [NoSideEffect, HasParent<"ModuleOp">]> {
   let summary = "Include operation";
   let description = [{
     The `include` operation allows to define a source file inclusion via the
     `#include` directive.
let description = [{
     ```
   }];
   let arguments = (ins
     Arg<StrAttr, "source file to include">:$include,
     UnitAttr:$is_standard_include
   );
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
-  let verifier = ?;
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITC

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 // Base class for Linalg dialect ops that do not correspond to library calls.
 class Linalg_Op<string mnemonic, list<Trait> traits = []> :
     Op<Linalg_Dialect, mnemonic, traits> {
   // For every linalg op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
-  //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 def Linalg_InitTensorOp : Linalg_Op<"init_tensor",
     [NoSideEffect,
      DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>]> {
   let summary = "operation to define a tensor of particular value";
 
   let description = [{
     `linalg.init_tensor` is an operation that materializes a tensor of
     a given shape. The shape could be dynamic or static.
   }];
 
   let arguments =
     (ins Variadic<Index>:$sizes, I64ArrayAttr:$static_sizes);
 
   let results = (outs AnyTensor:$result);
 
   let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes) attr-dict
     `:` type($result)
   }];
 
-  let verifier = [{ return ::verify(*this); }];
-
   let extraClassDeclaration = [{
     static StringRef getStaticSizesAttrName() {
       return "static_sizes";
     }
 
     RankedTensorType getType() {
       return getResult().getType().cast<RankedTensorType>(); }
 
let builders = [
     [{
       build($_builder, $_state, ValueRange{}, staticShape, elementType);
     }]>,
     OpBuilder<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Linalg_YieldOp : Linalg_Op<"yield", [NoSideEffect, ReturnLike, Terminator]>,
     Arguments<(ins Variadic<AnyType>:$values)> {
   let summary = "Linalg yield operation";
   let description = [{
     `linalg.yield` is a special terminator operation for blocks inside regions
     in `linalg` generic ops. It returns values to the immediately enclosing
     `linalg` generic op.
 
     Example:
 
     ```mlir
     linalg.yield %f0, %f1 : f32, f32
     ```
   }];
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
+  let hasVerifier = 1;
 }
 
 def Linalg_TiledLoopOp : Linalg_Op<"tiled_loop", [
      AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>,
      RecursiveSideEffects,
      SingleBlockImplicitTerminator<"linalg::YieldOp">
     ]> {
OpResult getTiedOpResult(OpOperand& opOperand) {
     bool isParallelDimension(unsigned dim) {
       StringAttr attr = this->iterator_types()[dim].cast<StringAttr>();
       return attr.getValue() == getParallelIteratorTypeName();
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Linalg_IndexOp : Linalg_Op<"index", [NoSideEffect]>,
     Arguments<(ins Confined<I64Attr, [IntMinValue<0>]>:$dim)>,
     Results<(outs Index:$result)> {
   let summary = "linalg index operation";
   let description = [{
     The `linalg.index` operation returns the iteration index of the immediately
scf.for %i = %c0 to %0 step %c1 {
         store %i, %I[%i, %j] : memref<?x?xindex>
         store %j, %J[%i, %j] : memref<?x?xindex>
       }
     }
     ```
   }];
 
   let assemblyFormat = [{ $dim attr-dict `:` type($result) }];
+  let hasVerifier = 1;
 }
 
 #endif // LINALG_OPS

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

`(` $value `,` $output `)` attr-dict `:`
         type($value) `,` type($output) (`->` type($result)^)?
       custom<FillOpRegion>($region, ref(type($value)), ref(type($output)))
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$value, "Value":$output)>
   ];
 
-  let verifier = [{ return ::verify(*this); }];
-
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Generic Linalg ops.
 //===----------------------------------------------------------------------===//
 
 def GenericOp : LinalgStructuredBase_Op<"generic", [AttrSizedOperandSegments]> {
   let description = [{
let extraClassDeclaration = structuredOpsBaseDecls # [{
     getRegionBuilder() {
       return nullptr;
     }
   }];
 
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parseGenericOp(parser, result); }];
 
-  let verifier = [{ return ::verify(*this); }];
-
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 
 //===----------------------------------------------------------------------===//
 // Named Linalg ops, implemented as a declarative configurations of generic ops.
 //===----------------------------------------------------------------------===//
 
 include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.td"
 
 #endif // LINALG_STRUCTURED_OPS

mlir/include/mlir/Dialect/Quant/QuantOps.td

def quant_QuantizeRegionOp : quant_Op<"region", [
   }];
 
   let arguments = (ins Variadic<AnyType>:$inputs,
                     TypeArrayAttr:$input_specs,
                     TypeArrayAttr:$output_specs,
                     StrAttr:$logical_kernel);
   let results = (outs Variadic<AnyType>:$outputs);
   let regions = (region SizedRegion<1>:$body);
-  let verifier = [{ return verifyRegionOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def quant_ReturnOp : quant_Op<"return", [Terminator]> {
   let summary = [{
     The `return` operation terminates a quantize region and returns values.
   }];
 
   let arguments = (ins Variadic<AnyTensor>:$results);
def quant_StatisticsOp : quant_Op<"stats", [SameOperandsAndResultType]> {
   }];
 
   let arguments = (ins
     quant_RealValueType:$arg,
     ElementsAttr:$layerStats,
     OptionalAttr<ElementsAttr>:$axisStats,
     OptionalAttr<I64Attr>:$axis);
   let results = (outs quant_RealValueType);
-
-  let verifier = [{
-    auto tensorArg = arg().getType().dyn_cast<TensorType>();
-    if (!tensorArg) return emitOpError("arg needs to be tensor type.");
-
-    // Verify layerStats attribute.
-    {
-      auto layerStatsType = layerStats().getType();
-      if (!layerStatsType.getElementType().isa<FloatType>()) {
-        return emitOpError(
-            "layerStats must have a floating point element type");
-      }
-      if (layerStatsType.getRank() != 1 || layerStatsType.getDimSize(0) != 2) {
-        return emitOpError("layerStats must have shape [2]");
-      }
-    }
-    // Verify axisStats (optional) attribute.
-    if (axisStats()) {
-      if (!axis()) return emitOpError("axis must be specified for axisStats");
-
-      auto shape = tensorArg.getShape();
-      auto argSliceSize = std::accumulate(std::next(shape.begin(),
-        *axis()), shape.end(), 1, std::multiplies<int64_t>());
-
-      auto axisStatsType = axisStats()->getType();
-      if (!axisStatsType.getElementType().isa<FloatType>()) {
-        return emitOpError("axisStats must have a floating point element type");
-      }
-      if (axisStatsType.getRank() != 2 ||
-          axisStatsType.getDimSize(1) != 2 ||
-          axisStatsType.getDimSize(0) != argSliceSize) {
-        return emitOpError("axisStats must have shape [N,2] "
-                           "where N = the slice size defined by the axis dim");
-      }
-    }
-    return success();
-  }];
+  let hasVerifier = 1;
 }
 
 def quant_CoupledRefOp : quant_Op<"coupled_ref", [SameOperandsAndResultType]> {
   let summary = [{
     Indicates that one point of the computation is coupled to another.
   }];
 
   let description = [{

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def Shape_AddOp : Shape_Op<"add",
 
   let arguments = (ins Shape_SizeOrIndexType:$lhs, Shape_SizeOrIndexType:$rhs);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
-  let verifier = [{ return verifySizeOrIndexOp(*this); }];
-
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, NoSideEffect]> {
   let summary = "Returns the broadcasted output shape of two or more inputs";
   let description = [{
     Returns the broadcasted shape for input shapes or extent tensors. The rest
     of this description is simplified for the 2 input case but can be extended
     to more inputs. Both operands can be of type `shape.shape` or
let builders = [OpBuilder<(ins "::mlir::Type":$result,
                                 "::mlir::Value":$lhs, "::mlir::Value":$rhs,
                                 "/*optional*/ ::mlir::StringAttr":$error), [{
       build($_builder, $_state, result, ::llvm::makeArrayRef({lhs, rhs}), error);
     }]>
   ];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def Shape_ConstShapeOp : Shape_Op<"const_shape",
     [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Creates a constant shape or extent tensor";
   let description = [{
     Creates a constant shape or extent tensor. The individual extents are given
     as the `shape` attribute. The number of these values equals the shape's
def Shape_DivOp : Shape_Op<"div", [NoSideEffect,
   let arguments = (ins Shape_SizeOrIndexType:$lhs,
                        Shape_SizeOrIndexType:$rhs);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
-  let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
def Shape_RankOp : Shape_Op<"rank",
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$rank);
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($rank)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
-  let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
let extraClassDeclaration = [{
     /// Get the `dim` value as integer if it is constant.
     Optional<int64_t> getConstantDim();
     /// Returns when two result types are compatible for this op; method used by
     /// InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
-  let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def Shape_IndexToSizeOp : Shape_Op<"index_to_size", [NoSideEffect]> {
   let summary = "Converts a standard index to a shape size";
   let description = [{
     Converts a standard index to a `shape.size`. This operation and its
     inverse, `size_to_index`, facilitate index conversion between the standard
     and the shape dialect.
def Shape_MulOp : Shape_Op<"mul",
 
   let arguments = (ins Shape_SizeOrIndexType:$lhs, Shape_SizeOrIndexType:$rhs);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
-  let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
def Shape_NumElementsOp : Shape_Op<"num_elements",
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($result)";
 
   let hasFolder = 1;
-  let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
+  let hasVerifier = 1;
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_ReduceOp : Shape_Op<"reduce",
def Shape_ReduceOp : Shape_Op<"reduce",
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape,
                        Variadic<AnyType>:$initVals);
   let results = (outs Variadic<AnyType>:$result);
   let regions = (region SizedRegion<1>:$region);
 
   let builders = [OpBuilder<(ins "Value":$shape, "ValueRange":$initVals)>];
 
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 def Shape_ShapeOfOp : Shape_Op<"shape_of",
     [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Returns shape of a value or shaped type operand";
 
   let description = [{
     The operation takes a value or a shaped operand as an argument and it
     returns a shape or extent tensor.
   }];
 
   let arguments = (ins AnyTypeOf<[AnyShaped, Shape_ValueShapeType]>:$arg);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($arg) `->` type($result)";
 
-  let verifier = [{ return ::verifyShapeOrExtentTensorOp(*this); }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
def Shape_YieldOp : Shape_Op<"yield",
   let summary = "Returns the value to parent op";
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [OpBuilder<(ins),
     [{ build($_builder, $_state, llvm::None); }]>
   ];
 
-  let verifier = [{ return ::verify(*this); }];
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
+  let hasVerifier = 1;
 }
 
 // TODO: Add Ops: if_static, if_ranked
 
 // For testing usage.
 def Shape_DebugPrintOp : Shape_Op<"debug_print", []> {
   let summary = "Prints the input shape or size";
   let description = [{
def Shape_AssumingAllOp : Shape_Op<"assuming_all", [Commutative, NoSideEffect]> {
   let builders = [
     OpBuilder<(ins "ValueRange":$inputs)>,
   ];
 
   let assemblyFormat = "$inputs attr-dict";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
-
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def Shape_AssumingOp : Shape_Op<"assuming", [
     SingleBlockImplicitTerminator<"AssumingYieldOp">,
     DeclareOpInterfaceMethods<RegionBranchOpInterface>,
     RecursiveSideEffects]> {
   let summary = "Execute the region";
   let description = [{
     Executes the region assuming all witnesses are true.
 
     "assuming" operations represent an execution order restriction to the
     compiler, information for dependent code to rely on (by assuming), and
     nothing else. They should not exist after a program is fully lowered and
     ready to execute.
   }];
   let arguments = (ins Shape_WitnessType:$witness);
   let regions = (region SizedRegion<1>:$doRegion);
   let results = (outs Variadic<AnyType>:$results);
 
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
-  let verifier = [{ return RegionBranchOpInterface::verifyTypes(*this); }];
 
   let extraClassDeclaration = [{
     // Inline the region into the region containing the AssumingOp and delete
     // the AssumingOp.
     //
     // This does no checks on the inputs to the AssumingOp.
     static void inlineRegionIntoParent(AssumingOp &op, PatternRewriter &rewriter);
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$witness,
         CArg<"function_ref<SmallVector<Value, 2>(OpBuilder &, Location)>">)>
   ];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Shape_AssumingYieldOp : Shape_Op<"assuming_yield",
        [NoSideEffect, ReturnLike, Terminator, HasParent<"AssumingOp">]> {
   let summary = "Yield operation";
   let description = [{
     This yield operation represents a return operation within the
     `shape.assuming` operation region. The operation takes variable number of
let extraClassDeclaration = [{
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::shape::WitnessType::get(context));
       return success();
     };
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative, InferTypeOpInterface]> {
   let summary = "Determines if all input shapes are equal";
   let description = [{
     Given 1 or more input shapes, determine if all shapes are the exact same.
 
     "cstr" operations represent runtime assertions.

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

def StandardOps_Dialect : Dialect {
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for Standard dialect ops.
 class Std_Op<string mnemonic, list<Trait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
-  //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//
 
 def AssertOp : Std_Op<"assert"> {
let description = [{
     ```mlir
     assert %b, "Expected ... to be true"
     ```
   }];
 
   let arguments = (ins I1:$arg, StrAttr:$msg);
 
   let assemblyFormat = "$arg `,` $msg attr-dict";
-
-  // AssertOp is fully verified by its traits.
-  let verifier = ?;
-
   let hasCanonicalizeMethod = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // BranchOp
 //===----------------------------------------------------------------------===//
 
 def BranchOp : Std_Op<"br",
def BranchOp : Std_Op<"br",
 
   let builders = [
     OpBuilder<(ins "Block *":$dest,
                   CArg<"ValueRange", "{}">:$destOperands), [{
       $_state.addSuccessors(dest);
       $_state.addOperands(destOperands);
     }]>];
 
-  // BranchOp is fully verified by traits.
-  let verifier = ?;
-
   let extraClassDeclaration = [{
     void setDest(Block *block);
 
     /// Erase the operand at 'index' from the operand list.
     void eraseOperand(unsigned index);
   }];
 
   let hasCanonicalizeMethod = 1;
let extraClassDeclaration = [{
     CallInterfaceCallable getCallableForCallee() {
       return (*this)->getAttrOfType<SymbolRefAttr>("callee");
     }
   }];
 
   let assemblyFormat = [{
     $callee `(` $operands `)` attr-dict `:` functional-type($operands, results)
   }];
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // CallIndirectOp
 //===----------------------------------------------------------------------===//
 
 def CallIndirectOp : Std_Op<"call_indirect", [
       CallOpInterface,
let extraClassDeclaration = [{
 
     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 hasCanonicalizeMethod = 1;
 
   let assemblyFormat =
     "$callee `(` $callee_operands `)` attr-dict `:` type($callee)";
 }
 
 //===----------------------------------------------------------------------===//
 // CondBranchOp
OpBuilder<(ins "Value":$condition, "Block *":$trueDest,
             falseDest);
     }]>,
     OpBuilder<(ins "Value":$condition, "Block *":$trueDest,
       "Block *":$falseDest, CArg<"ValueRange", "{}">:$falseOperands), [{
       build($_builder, $_state, condition, trueDest, ValueRange(), falseDest,
             falseOperands);
     }]>];
 
-  // CondBranchOp is fully verified by traits.
-  let verifier = ?;
-
   let extraClassDeclaration = [{
     // These are the indices into the dests list.
     enum { trueIndex = 0, falseIndex = 1 };
 
     // Accessors for operands to the 'true' destination.
     Value getTrueOperand(unsigned idx) {
       assert(idx < getNumTrueOperands());
       return getOperand(getTrueDestOperandIndex() + idx);
def ConstantOp : Std_Op<"constant",
 
   let extraClassDeclaration = [{
     /// Returns true if a constant operation can be built with the given value
     /// and result type.
     static bool isBuildableWith(Attribute value, Type type);
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 def ReturnOp : Std_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
                                 MemRefsNormalizable, ReturnLike, Terminator]> {
def ReturnOp : Std_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [
     OpBuilder<(ins),
     [{ build($_builder, $_state, llvm::None); }]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
 def SelectOp : Std_Op<"select", [NoSideEffect,
     AllTypesMatch<["true_value", "false_value", "result"]>,
def SelectOp : Std_Op<"select", [NoSideEffect,
 
   let arguments = (ins BoolLike:$condition,
                        AnyType:$true_value,
                        AnyType:$false_value);
   let results = (outs AnyType:$result);
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 def SplatOp : Std_Op<"splat", [NoSideEffect,
      TypesMatchWith<"operand type matches element type of result",
def SplatOp : Std_Op<"splat", [NoSideEffect,
   let results = (outs AnyTypeOf<[AnyVectorOfAnyRank,
                                  AnyStaticShapeTensor]>:$aggregate);
 
   let builders = [
     OpBuilder<(ins "Value":$element, "Type":$aggregateType),
     [{ build($_builder, $_state, aggregateType, element); }]>];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let assemblyFormat = "$input attr-dict `:` type($aggregate)";
 }
 
 //===----------------------------------------------------------------------===//
 // SwitchOp
 //===----------------------------------------------------------------------===//
 
let extraClassDeclaration = [{
     /// Return a mutable range of operands for the case destination block at the
     /// given index.
     MutableOperandRange getCaseOperandsMutable(unsigned index) {
       return getCaseOperandsMutable()[index];
     }
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 #endif // STANDARD_OPS

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.td

let arguments = (ins
     OptionalAttr<Tosa_UnaryOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor4D:$output
   );
 
   let builders = [Tosa_AvgPool2dOpQuantInfoBuilder];
-
-  let verifier = [{ return verifyAveragePoolOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_Conv2DOp : Tosa_Op<"conv2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
let arguments = (ins
     OptionalAttr<Tosa_ConvOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor4D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
-
-  let verifier = [{ return verifyConvOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: conv3d
 //===----------------------------------------------------------------------===//
 def Tosa_Conv3DOp : Tosa_Op<"conv3d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
let arguments = (ins
     OptionalAttr<Tosa_ConvOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor5D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
-
-  let verifier = [{ return verifyConvOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: depthwise_conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_DepthwiseConv2DOp : Tosa_Op<"depthwise_conv2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
let arguments = (ins
     OptionalAttr<Tosa_ConvOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor4D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
-
-  let verifier = [{ return verifyConvOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: fully_connected
 //===----------------------------------------------------------------------===//
 def Tosa_FullyConnectedOp : Tosa_Op<"fully_connected", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
let arguments = (ins
     OptionalAttr<Tosa_ConvOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor2D:$output
   );
 
   let builders = [Tosa_FCOpQuantInfoBuilder];
-
-  let verifier = [{ return verifyConvOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: matmul
 //===----------------------------------------------------------------------===//
 def Tosa_MatMulOp : Tosa_Op<"matmul", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,

mlir/include/mlir/IR/BuiltinOps.td

let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     bool isDeclaration() { return isExternal(); }
   }];
   let parser = [{ return ::parseFuncOp(parser, result); }];
   let printer = [{ return ::print(*this, p); }];
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp
 //===----------------------------------------------------------------------===//
 
 def ModuleOp : Builtin_Op<"module", [
     AffineScope, IsolatedFromAbove, NoRegionArguments, SymbolTable, Symbol,
let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // OpAsmOpInterface Methods
     //===------------------------------------------------------------------===//
 
     static ::llvm::StringRef getDefaultDialect() {
       return "builtin";
     }
   }];
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 
   // We need to ensure the block inside the region is properly terminated;
   // the auto-generated builders do not guarantee that.
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp

mlir/include/mlir/IR/OpBase.td

 // Base class for ops with static/dynamic offset, sizes and strides
 // attributes/arguments.
 class BaseOpWithOffsetSizesAndStrides<Dialect dialect, string mnemonic,
                                       list<Trait> traits = []> :
   Op<dialect, mnemonic, traits> {
 
   // For every such op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
-  //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 
   code extraBaseClassDeclaration = [{
     /// Returns the dynamic sizes for this subview operation if specified.
     ::mlir::Operation::operand_range getDynamicSizes() { return sizes(); }
 
     /// Return the list of Range (i.e. offset, size, stride). Each
     /// Range entry contains either the dynamic value or a ConstantIndexOp

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

if (auto intCst = getValue().dyn_cast<IntegerAttr>()) {
     setNameFn(getResult(), specialName.str());
   } else {
     setNameFn(getResult(), "cst");
   }
 }
 
 /// TODO: disallow arith.constant to return anything other than signless integer
 /// or float like.
-static LogicalResult verify(arith::ConstantOp op) {
-  auto type = op.getType();
+LogicalResult arith::ConstantOp::verify() {
+  auto type = getType();
   // The value's type must match the return type.
-  if (op.getValue().getType() != type) {
-    return op.emitOpError() << "value type " << op.getValue().getType()
-                            << " must match return type: " << type;
+  if (getValue().getType() != type) {
+    return emitOpError() << "value type " << getValue().getType()
   }
   // Integer values must be signless.
   if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
-    return op.emitOpError("integer return type must be signless");
+    return emitOpError("integer return type must be signless");
   // Any float or elements attribute are acceptable.
-  if (!op.getValue().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
-    return op.emitOpError(
+  if (!getValue().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
+    return emitOpError(
         "value must be an integer, float, or elements attribute");
   }
   return success();
 }
 
 bool arith::ConstantOp::isBuildableWith(Attribute value, Type type) {
   // The value's type must be the same as the provided type.
   if (value.getType() != type)
OpFoldResult arith::ExtUIOp::fold(ArrayRef<Attribute> operands) {
 
   return {};
 }
 
 bool arith::ExtUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::greater, IntegerType>(inputs, outputs);
 }
 
+LogicalResult arith::ExtUIOp::verify() {
+  return verifyExtOp<IntegerType>(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // ExtSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::ExtSIOp::fold(ArrayRef<Attribute> operands) {
   if (auto lhs = operands[0].dyn_cast_or_null<IntegerAttr>())
     return IntegerAttr::get(
         getType(), lhs.getValue().sext(getType().getIntOrFloatBitWidth()));
bool arith::ExtSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::greater, IntegerType>(inputs, outputs);
 }
 
 void arith::ExtSIOp::getCanonicalizationPatterns(
     RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<ExtSIOfExtUI>(context);
 }
 
+LogicalResult arith::ExtSIOp::verify() {
+  return verifyExtOp<IntegerType>(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // ExtFOp
 //===----------------------------------------------------------------------===//
 
 bool arith::ExtFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::greater, FloatType>(inputs, outputs);
 }
 
+LogicalResult arith::ExtFOp::verify() { return verifyExtOp<FloatType>(*this); }
+
 //===----------------------------------------------------------------------===//
 // TruncIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::TruncIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "unary operation takes one operand");
 
   // trunci(zexti(a)) -> a
OpFoldResult arith::TruncIOp::fold(ArrayRef<Attribute> operands) {
 
   return {};
 }
 
 bool arith::TruncIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::less, IntegerType>(inputs, outputs);
 }
 
+LogicalResult arith::TruncIOp::verify() {
+  return verifyTruncateOp<IntegerType>(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // TruncFOp
 //===----------------------------------------------------------------------===//
 
 /// Perform safe const propagation for truncf, i.e. only propagate if FP value
 /// can be represented without precision loss or rounding.
 OpFoldResult arith::TruncFOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "unary operation takes one operand");
OpFoldResult arith::TruncFOp::fold(ArrayRef<Attribute> operands) {
 
   return {};
 }
 
 bool arith::TruncFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkWidthChangeCast<std::less, FloatType>(inputs, outputs);
 }
 
+LogicalResult arith::TruncFOp::verify() {
+  return verifyTruncateOp<FloatType>(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // AndIOp
 //===----------------------------------------------------------------------===//
 
 void arith::AndIOp::getCanonicalizationPatterns(
     RewritePatternSet &patterns, MLIRContext *context) {
   patterns.insert<AndOfExtUI, AndOfExtSI>(context);
 }

mlir/lib/Dialect/Async/IR/Async.cpp

 #include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(YieldOp op) {
+LogicalResult YieldOp::verify() {
   // Get the underlying value types from async values returned from the
   // parent `async.execute` operation.
-  auto executeOp = op->getParentOfType<ExecuteOp>();
+  auto executeOp = (*this)->getParentOfType<ExecuteOp>();
   auto types = llvm::map_range(executeOp.results(), [](const OpResult &result) {
     return result.getType().cast<ValueType>().getValueType();
   });
 
-  if (op.getOperandTypes() != types)
-    return op.emitOpError("operand types do not match the types returned from "
-                          "the parent ExecuteOp");
+  if (getOperandTypes() != types)
+    return emitOpError("operand types do not match the types returned from "
 
   return success();
 }
 
 MutableOperandRange
 YieldOp::getMutableSuccessorOperands(Optional<unsigned> index) {
   assert(!index.hasValue());
   return operandsMutable();
if (parser.parseRegion(*body, /*arguments=*/{unwrappedArgs},
                          /*argTypes=*/{unwrappedTypes},
                          /*argLocations=*/{},
                          /*enableNameShadowing=*/false))
     return failure();
 
   return success();
 }
 
-static LogicalResult verify(ExecuteOp op) {
+LogicalResult ExecuteOp::verify() {
   // Unwrap async.execute value operands types.
-  auto unwrappedTypes = llvm::map_range(op.operands(), [](Value operand) {
+  auto unwrappedTypes = llvm::map_range(operands(), [](Value operand) {
     return operand.getType().cast<ValueType>().getValueType();
   });
 
   // Verify that unwrapped argument types matches the body region arguments.
-  if (op.body().getArgumentTypes() != unwrappedTypes)
-    return op.emitOpError("async body region argument types do not match the "
-                          "execute operation arguments types");
+  if (body().getArgumentTypes() != unwrappedTypes)
+    return emitOpError("async body region argument types do not match the "
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 /// CreateGroupOp
 //===----------------------------------------------------------------------===//
 
static ParseResult parseAwaitResultType(OpAsmParser &parser, Type &operandType,
   return success();
 }
 
 static void printAwaitResultType(OpAsmPrinter &p, Operation *op,
                                  Type operandType, Type resultType) {
   p << operandType;
 }
 
-static LogicalResult verify(AwaitOp op) {
-  Type argType = op.operand().getType();
+LogicalResult AwaitOp::verify() {
+  Type argType = operand().getType();
 
   // Awaiting on a token does not have any results.
-  if (argType.isa<TokenType>() && !op.getResultTypes().empty())
-    return op.emitOpError("awaiting on a token must have empty result");
+  if (argType.isa<TokenType>() && !getResultTypes().empty())
+    return emitOpError("awaiting on a token must have empty result");
 
   // Awaiting on a value unwraps the async value type.
   if (auto value = argType.dyn_cast<ValueType>()) {
-    if (*op.getResultType() != value.getValueType())
-      return op.emitOpError()
-             << "result type " << *op.getResultType()
-             << " does not match async value type " << value.getValueType();
+    if (*getResultType() != value.getValueType())
+      return emitOpError() << "result type " << *getResultType()
+                           << " does not match async value type "
+                           << value.getValueType();
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Complex/IR/ComplexOps.cpp

if (!complexTy)
       return false;
     auto complexEltTy = complexTy.getElementType();
     return arrAttr.size() == 2 && arrAttr[0].getType() == complexEltTy &&
            arrAttr[1].getType() == complexEltTy;
   }
   return false;
 }
 
-static LogicalResult verify(ConstantOp op) {
-  ArrayAttr arrayAttr = op.getValue();
+LogicalResult ConstantOp::verify() {
+  ArrayAttr arrayAttr = getValue();
   if (arrayAttr.size() != 2) {
-    return op.emitOpError(
+    return emitOpError(
         "requires 'value' to be a complex constant, represented as array of "
         "two values");
   }
 
-  auto complexEltTy = op.getType().getElementType();
+  auto complexEltTy = getType().getElementType();
   if (complexEltTy != arrayAttr[0].getType() ||
       complexEltTy != arrayAttr[1].getType()) {
-    return op.emitOpError()
+    return emitOpError()
            << "requires attribute's element types (" << arrayAttr[0].getType()
            << ", " << arrayAttr[1].getType()
            << ") to match the element type of the op's return type ("
            << complexEltTy << ")";
   }
   return success();
 }
 

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

Operation *EmitCDialect::materializeConstant(OpBuilder &builder,
                                              Location loc) {
   return builder.create<emitc::ConstantOp>(loc, type, value);
 }
 
 //===----------------------------------------------------------------------===//
 // ApplyOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ApplyOp op) {
-  StringRef applicableOperator = op.applicableOperator();
+LogicalResult ApplyOp::verify() {
+  StringRef applicableOperatorStr = applicableOperator();
 
   // Applicable operator must not be empty.
-  if (applicableOperator.empty())
-    return op.emitOpError("applicable operator must not be empty");
+  if (applicableOperatorStr.empty())
+    return emitOpError("applicable operator must not be empty");
 
   // Only `*` and `&` are supported.
-  if (applicableOperator != "&" && applicableOperator != "*")
-    return op.emitOpError("applicable operator is illegal");
+  if (applicableOperatorStr != "&" && applicableOperatorStr != "*")
+    return emitOpError("applicable operator is illegal");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(emitc::CallOp op) {
+LogicalResult emitc::CallOp::verify() {
   // Callee must not be empty.
-  if (op.callee().empty())
-    return op.emitOpError("callee must not be empty");
+  if (callee().empty())
+    return emitOpError("callee must not be empty");
 
-  if (Optional<ArrayAttr> argsAttr = op.args()) {
+  if (Optional<ArrayAttr> argsAttr = args()) {
     for (Attribute arg : argsAttr.getValue()) {
       if (arg.getType().isa<IndexType>()) {
         int64_t index = arg.cast<IntegerAttr>().getInt();
         // Args with elements of type index must be in range
         // [0..operands.size).
-        if ((index < 0) || (index >= static_cast<int64_t>(op.getNumOperands())))
-          return op.emitOpError("index argument is out of range");
+        if ((index < 0) || (index >= static_cast<int64_t>(getNumOperands())))
+          return emitOpError("index argument is out of range");
 
         // Args with elements of type ArrayAttr must have a type.
       } else if (arg.isa<ArrayAttr>() && arg.getType().isa<NoneType>()) {
-        return op.emitOpError("array argument has no type");
+        return emitOpError("array argument has no type");
       }
     }
   }
 
-  if (Optional<ArrayAttr> templateArgsAttr = op.template_args()) {
+  if (Optional<ArrayAttr> templateArgsAttr = template_args()) {
     for (Attribute tArg : templateArgsAttr.getValue()) {
       if (!tArg.isa<TypeAttr>() && !tArg.isa<IntegerAttr>() &&
           !tArg.isa<FloatAttr>() && !tArg.isa<emitc::OpaqueAttr>())
-        return op.emitOpError("template argument has invalid type");
+        return emitOpError("template argument has invalid type");
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 /// The constant op requires that the attribute's type matches the return type.
-static LogicalResult verify(emitc::ConstantOp &op) {
-  Attribute value = op.value();
-  Type type = op.getType();
+LogicalResult emitc::ConstantOp::verify() {
+  Attribute value = valueAttr();
+  Type type = getType();
   if (!value.getType().isa<NoneType>() && type != value.getType())
-    return op.emitOpError() << "requires attribute's type (" << value.getType()
-                            << ") to match op's return type (" << type << ")";
+    return emitOpError() << "requires attribute's type (" << value.getType()
   return success();
 }
 
 OpFoldResult emitc::ConstantOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "constant has no operands");
   return value();
 }
 

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

ParseResult parseFillOpRegion(OpAsmParser &parser, Region &r, Type valueType,
   fillStructuredOpRegion<FillOp>(opBuilder, r, TypeRange{valueType},
                                  TypeRange{outputType});
   return success();
 }
 
 /// FillOp region is elided when printing.
 void printFillOpRegion(OpAsmPrinter &, Operation *, Region &, Type, Type) {}
 
-static LogicalResult verify(FillOp op) {
-  OpOperand *output = op.getOutputOperand(0);
-  Type fillType = op.value().getType();
+LogicalResult FillOp::verify() {
+  OpOperand *output = getOutputOperand(0);
+  Type fillType = value().getType();
   if (getElementTypeOrSelf(output->get()) != fillType)
-    return op.emitOpError("expects fill type to match view elemental type");
+    return emitOpError("expects fill type to match view elemental type");
   return success();
 }
 
 void FillOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   if (output().getType().isa<MemRefType>())
     effects.emplace_back(MemoryEffects::Write::get(), output(),
getGenericEffectsImpl(effects, getOperation()->getResults(), inputBuffers,
                         outputBuffers);
 }
 
 template <typename GenericOpType>
 static LogicalResult verifyGenericOp(GenericOpType op) {
   return success();
 }
 
-static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); }
+LogicalResult GenericOp::verify() { return verifyGenericOp(*this); }
 
 namespace {
 // Deduplicate redundant args of a linalg generic op.
 // An arg is redundant if it has the same Value and indexing map as another.
 struct DeduplicateGenericOpInputs : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
void InitTensorOp::build(OpBuilder &b, OperationState &result,
   SmallVector<int64_t, 4> staticSizes;
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   auto resultType = RankedTensorType ::get(staticSizes, elementType);
   build(b, result, resultType, dynamicSizes, b.getI64ArrayAttr(staticSizes));
   result.addAttributes(attrs);
 }
 
-static LogicalResult verify(InitTensorOp op) {
-  RankedTensorType resultType = op.getType();
+LogicalResult InitTensorOp::verify() {
+  RankedTensorType resultType = getType();
   SmallVector<int64_t, 4> staticSizes = llvm::to_vector<4>(llvm::map_range(
-      op.static_sizes().cast<ArrayAttr>(),
+      static_sizes().cast<ArrayAttr>(),
       [](Attribute a) -> int64_t { return a.cast<IntegerAttr>().getInt(); }));
 
-  if (failed(verifyListOfOperandsOrIntegers(op, "sizes", resultType.getRank(),
-                                            op.static_sizes(), op.sizes(),
-                                            ShapedType::isDynamic)))
+  if (failed(verifyListOfOperandsOrIntegers(
+          *this, "sizes", resultType.getRank(), static_sizes(), sizes(),
     return failure();
 
-  if (op.static_sizes().size() != static_cast<unsigned>(resultType.getRank()))
-    return op->emitError("expected ")
-           << resultType.getRank() << " sizes values";
+  if (static_sizes().size() != static_cast<unsigned>(resultType.getRank()))
+    return emitError("expected ") << resultType.getRank() << " sizes values";
 
   Type expectedType = InitTensorOp::inferResultType(
       staticSizes, resultType.getElementType(), resultType.getEncoding());
   if (resultType != expectedType) {
-    return op.emitError("specified type ")
+    return emitError("specified type ")
            << resultType << " does not match the inferred type "
            << expectedType;
   }
   return success();
 }
 
 Type InitTensorOp::inferResultType(ArrayRef<int64_t> staticSizes,
                                    Type elementType, Attribute encoding) {
if (opOperand.get().getType() != elementType)
              << (opOperand.getOperandNumber() + 1) << " ("
              << opOperand.get().getType() << ") doesn't match "
              << "the element type of the enclosing linalg.generic op ("
              << elementType << ")";
   }
   return success();
 }
 
-static LogicalResult verify(linalg::YieldOp op) {
-  auto *parentOp = op->getParentOp();
+LogicalResult linalg::YieldOp::verify() {
+  auto *parentOp = (*this)->getParentOp();
   if (parentOp->getNumRegions() != 1 || parentOp->getRegion(0).empty())
-    return op.emitOpError("expected single non-empty parent region");
+    return emitOpError("expected single non-empty parent region");
 
   if (auto linalgOp = dyn_cast<LinalgOp>(parentOp))
-    return verifyYield(op, cast<LinalgOp>(parentOp));
+    return verifyYield(*this, cast<LinalgOp>(parentOp));
 
   if (auto tiledLoopOp = dyn_cast<linalg::TiledLoopOp>(parentOp)) {
     // Check if output args with tensor types match results types.
     SmallVector<Value, 2> tensorOuts;
     llvm::copy_if(
         tiledLoopOp.outputs(), std::back_inserter(tensorOuts),
         [&](Value out) { return out.getType().isa<RankedTensorType>(); });
-    if (tensorOuts.size() != op.values().size())
-      return op.emitOpError("expected number of tensor output args = ")
-             << tensorOuts.size() << " to match the number of yield operands = "
-             << op.values().size();
+    if (tensorOuts.size() != values().size())
+      return emitOpError("expected number of tensor output args = ")
+             << tensorOuts.size()
+             << " to match the number of yield operands = " << values().size();
 
     TypeRange tensorTypes(llvm::makeArrayRef(tensorOuts));
     for (auto &item :
-         llvm::enumerate(llvm::zip(tensorTypes, op.getOperandTypes()))) {
+         llvm::enumerate(llvm::zip(tensorTypes, getOperandTypes()))) {
       Type outType, resultType;
       unsigned index = item.index();
       std::tie(outType, resultType) = item.value();
       if (outType != resultType)
-        return op.emitOpError("expected yield operand ")
+        return emitOpError("expected yield operand ")
                << index << " with type = " << resultType
                << " to match output arg type = " << outType;
     }
     return success();
   }
-  return op.emitOpError("expected parent op with LinalgOp interface");
+  return emitOpError("expected parent op with LinalgOp interface");
 }
 
 //===----------------------------------------------------------------------===//
 // TiledLoopOp
 //===----------------------------------------------------------------------===//
 
 void TiledLoopOp::build(OpBuilder &builder, OperationState &result,
                         ValueRange lowerBounds, ValueRange upperBounds,
for (auto *op : ops)
     op->moveBefore(*this);
   return success();
 }
 
 bool TiledLoopOp::isDefinedOutsideOfLoop(Value value) {
   return !region().isAncestor(value.getParentRegion());
 }
 
-static LogicalResult verify(TiledLoopOp op) {
+LogicalResult TiledLoopOp::verify() {
   // Check if iterator types are provided for every loop dimension.
-  if (op.iterator_types().size() != op.getNumLoops())
-    return op.emitOpError("expected iterator types array attribute size = ")
-           << op.iterator_types().size()
-           << " to match the number of loops = " << op.getNumLoops();
+  if (iterator_types().size() != getNumLoops())
+    return emitOpError("expected iterator types array attribute size = ")
+           << iterator_types().size()
+           << " to match the number of loops = " << getNumLoops();
 
   // Check if types of input arguments match region args types.
   for (auto &item :
-       llvm::enumerate(llvm::zip(op.inputs(), op.getRegionInputArgs()))) {
+       llvm::enumerate(llvm::zip(inputs(), getRegionInputArgs()))) {
     Value input, inputRegionArg;
     unsigned index = item.index();
     std::tie(input, inputRegionArg) = item.value();
     if (input.getType() != inputRegionArg.getType())
-      return op.emitOpError("expected input arg ")
+      return emitOpError("expected input arg ")
              << index << " with type = " << input.getType()
-             << " to match region arg " << index + op.getNumLoops()
+             << " to match region arg " << index + getNumLoops()
              << " type = " << inputRegionArg.getType();
   }
 
   // Check if types of input arguments match region args types.
   for (auto &item :
-       llvm::enumerate(llvm::zip(op.outputs(), op.getRegionOutputArgs()))) {
+       llvm::enumerate(llvm::zip(outputs(), getRegionOutputArgs()))) {
     Value output, outputRegionArg;
     unsigned index = item.index();
     std::tie(output, outputRegionArg) = item.value();
     if (output.getType() != outputRegionArg.getType())
-      return op.emitOpError("expected output arg ")
+      return emitOpError("expected output arg ")
              << index << " with type = " << output.getType()
              << " to match region arg "
-             << index + op.getNumLoops() + op.inputs().size()
+             << index + getNumLoops() + inputs().size()
              << " type = " << outputRegionArg.getType();
   }
   return success();
 }
 
 namespace {
 
 static constexpr int64_t kNoMatch = -1;
LogicalResult TiledLoopOp::fold(ArrayRef<Attribute>,
                                 SmallVectorImpl<OpFoldResult> &) {
   return foldMemRefCastInTiledLoopOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // IndexOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(IndexOp op) {
-  auto linalgOp = dyn_cast<LinalgOp>(op->getParentOp());
+LogicalResult IndexOp::verify() {
+  auto linalgOp = dyn_cast<LinalgOp>((*this)->getParentOp());
   if (!linalgOp)
-    return op.emitOpError("expected parent op with LinalgOp interface");
-  if (linalgOp.getNumLoops() <= op.dim())
-    return op.emitOpError("expected dim (")
-           << op.dim() << ") to be lower than the number of loops ("
+    return emitOpError("expected parent op with LinalgOp interface");
+  if (linalgOp.getNumLoops() <= dim())
+    return emitOpError("expected dim (")
+           << dim() << ") to be lower than the number of loops ("
            << linalgOp.getNumLoops() << ") of the enclosing LinalgOp";
   return success();
 }
 
 /////// Operations corresponding to library calls defined with Tablegen ////////
 
 #include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.cpp.inc"
 

mlir/lib/Dialect/Quant/IR/QuantOps.cpp

if (auto tensorType = expressed.dyn_cast<TensorType>())
       return spec == tensorType.getElementType();
 
     if (auto vectorType = expressed.dyn_cast<VectorType>())
       return spec == vectorType.getElementType();
   }
   return false;
 }
 
-static LogicalResult verifyRegionOp(QuantizeRegionOp op) {
+LogicalResult QuantizeRegionOp::verify() {
   // There are specifications for both inputs and outputs.
-  if (op.getNumOperands() != op.input_specs().size() ||
-      op.getNumResults() != op.output_specs().size())
-    return op.emitOpError(
+  if (getNumOperands() != input_specs().size() ||
+      getNumResults() != output_specs().size())
+    return emitOpError(
         "has unmatched operands/results number and spec attributes number");
 
   // Verify that quantization specifications are valid.
-  for (auto input : llvm::zip(op.getOperandTypes(), op.input_specs())) {
+  for (auto input : llvm::zip(getOperandTypes(), input_specs())) {
     Type inputType = std::get<0>(input);
     Attribute inputSpec = std::get<1>(input);
     if (!isValidQuantizationSpec(inputSpec, inputType)) {
-      return op.emitOpError() << "has incompatible specification " << inputSpec
-                              << " and input type " << inputType;
+      return emitOpError() << "has incompatible specification " << inputSpec
     }
   }
 
-  for (auto result : llvm::zip(op.getResultTypes(), op.output_specs())) {
+  for (auto result : llvm::zip(getResultTypes(), output_specs())) {
     Type outputType = std::get<0>(result);
     Attribute outputSpec = std::get<1>(result);
     if (!isValidQuantizationSpec(outputSpec, outputType)) {
-      return op.emitOpError() << "has incompatible specification " << outputSpec
-                              << " and output type " << outputType;
+      return emitOpError() << "has incompatible specification " << outputSpec
     }
   }
   return success();
 }
 
+LogicalResult StatisticsOp::verify() {
+  auto tensorArg = arg().getType().dyn_cast<TensorType>();
+  if (!tensorArg)
+    return emitOpError("arg needs to be tensor type.");
+
+  // Verify layerStats attribute.
+  {
+    auto layerStatsType = layerStats().getType();
+    if (!layerStatsType.getElementType().isa<FloatType>()) {
+      return emitOpError("layerStats must have a floating point element type");
+    }
+    if (layerStatsType.getRank() != 1 || layerStatsType.getDimSize(0) != 2) {
+      return emitOpError("layerStats must have shape [2]");
+    }
+  }
+  // Verify axisStats (optional) attribute.
+  if (axisStats()) {
+    if (!axis())
+      return emitOpError("axis must be specified for axisStats");
+
+    auto shape = tensorArg.getShape();
+    auto argSliceSize =
+        std::accumulate(std::next(shape.begin(), *axis()), shape.end(), 1,
+                        std::multiplies<int64_t>());
+
+    auto axisStatsType = axisStats()->getType();
+    if (!axisStatsType.getElementType().isa<FloatType>()) {
+      return emitOpError("axisStats must have a floating point element type");
+    }
+    if (axisStatsType.getRank() != 2 || axisStatsType.getDimSize(1) != 2 ||
+        axisStatsType.getDimSize(0) != argSliceSize) {
+      return emitOpError("axisStats must have shape [N,2] "
+                         "where N = the slice size defined by the axis dim");
+    }
+  }
+  return success();
+}
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Quant/QuantOps.cpp.inc"

mlir/lib/Dialect/Shape/IR/Shape.cpp

void AssumingOp::build(
   builder.create<AssumingYieldOp>(result.location, yieldValues);
 
   SmallVector<Type, 2> assumingTypes;
   for (Value v : yieldValues)
     assumingTypes.push_back(v.getType());
   result.addTypes(assumingTypes);
 }
 
+LogicalResult AssumingOp::verify() {
+  return RegionBranchOpInterface::verifyTypes(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
OpFoldResult mlir::shape::AddOp::fold(ArrayRef<Attribute> operands) {
   // add(x, 0) -> x
   if (matchPattern(getRhs(), m_Zero()))
     return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) + b; });
 }
 
+LogicalResult shape::AddOp::verify() { return verifySizeOrIndexOp(*this); }
+
 //===----------------------------------------------------------------------===//
 // AssumingAllOp
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct AssumingAllToCstrEqCanonicalization
     : public OpRewritePattern<AssumingAllOp> {
   using OpRewritePattern<AssumingAllOp>::OpRewritePattern;
for (int idx = operands.size() - 1; idx >= 0; idx--) {
     // Always false if any input is statically known false
     if (!a.cast<BoolAttr>().getValue())
       return a;
   }
   // If this is reached, all inputs were statically known passing.
   return BoolAttr::get(getContext(), true);
 }
 
-static LogicalResult verify(AssumingAllOp op) {
+LogicalResult AssumingAllOp::verify() {
   // Ensure that AssumingAllOp contains at least one operand
-  if (op.getNumOperands() == 0)
-    return op.emitOpError("no operands specified");
+  if (getNumOperands() == 0)
+    return emitOpError("no operands specified");
 
   return success();
 }
 
 void AssumingAllOp::build(OpBuilder &b, OperationState &state,
                           ValueRange inputs) {
   build(b, state, b.getType<WitnessType>(), inputs);
 }
OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
   // TODO: Fold to an "error".
   if (!OpTrait::util::getBroadcastedShape(lhsShape, rhsShape, resultShape))
     return nullptr;
 
   Builder builder(getContext());
   return builder.getIndexTensorAttr(resultShape);
 }
 
-static LogicalResult verify(BroadcastOp op) {
-  return verifyShapeOrExtentTensorOp(op);
+LogicalResult BroadcastOp::verify() {
+  return verifyShapeOrExtentTensorOp(*this);
 }
 
 namespace {
 template <typename OpTy>
 struct RemoveEmptyShapeOperandsPattern : public OpRewritePattern<OpTy> {
   using OpRewritePattern<OpTy>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(OpTy op,
if ([&] {
       }())
     return BoolAttr::get(getContext(), true);
 
   // Because a failing witness result here represents an eventual assertion
   // failure, we do not replace it with a constant witness.
   return nullptr;
 }
 
-static LogicalResult verify(CstrBroadcastableOp op) {
+LogicalResult CstrBroadcastableOp::verify() {
   // Ensure that AssumingAllOp contains at least one operand
-  if (op.getNumOperands() < 2)
-    return op.emitOpError("required at least 2 input shapes");
+  if (getNumOperands() < 2)
+    return emitOpError("required at least 2 input shapes");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CstrEqOp
 //===----------------------------------------------------------------------===//
 
 void CstrEqOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
LogicalResult mlir::shape::DivOp::inferReturnTypes(
   return success();
 }
 
 bool mlir::shape::DivOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
+LogicalResult DivOp::verify() { return verifySizeOrIndexOp(*this); }
+
 //===----------------------------------------------------------------------===//
 // ShapeEqOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ShapeEqOp::fold(ArrayRef<Attribute> operands) {
   bool allSame = true;
   if (!operands.empty() && !operands[0])
     return {};

 }
 
 bool mlir::shape::GetExtentOp::isCompatibleReturnTypes(TypeRange l,
                                                        TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
+LogicalResult GetExtentOp::verify() { return verifySizeOrIndexOp(*this); }
+
 //===----------------------------------------------------------------------===//
 // IsBroadcastableOp
 //===----------------------------------------------------------------------===//
 
 void IsBroadcastableOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                     MLIRContext *context) {
   patterns.add<RemoveDuplicateOperandsPattern<IsBroadcastableOp>>(context);
 }
LogicalResult mlir::shape::RankOp::inferReturnTypes(
   return success();
 }
 
 bool mlir::shape::RankOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
+LogicalResult shape::RankOp::verify() { return verifySizeOrIndexOp(*this); }
+
 //===----------------------------------------------------------------------===//
 // NumElementsOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult NumElementsOp::fold(ArrayRef<Attribute> operands) {
 
   // Fold only when argument constant.
   Attribute shape = operands[0];

 }
 
 bool mlir::shape::NumElementsOp::isCompatibleReturnTypes(TypeRange l,
                                                          TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
+LogicalResult shape::NumElementsOp::verify() {
+  return verifySizeOrIndexOp(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // MaxOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::MulOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
+
+LogicalResult shape::MulOp::verify() { return verifySizeOrIndexOp(*this); }
+
 //===----------------------------------------------------------------------===//
 // ShapeOfOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ShapeOfOp::fold(ArrayRef<Attribute>) {
   auto type = getOperand().getType().dyn_cast<ShapedType>();
   if (!type || !type.hasStaticShape())
     return nullptr;
if (lhs.isa<ShapeType>() || rhs.isa<ShapeType>())
     // Shape type is compatible with all other valid return types.
     return true;
 
   if (succeeded(verifyCompatibleShapes({lhs, rhs})))
     return true;
   return false;
 }
 
+LogicalResult shape::ShapeOfOp::verify() {
+  return verifyShapeOrExtentTensorOp(*this);
+}
+
 //===----------------------------------------------------------------------===//
 // SizeToIndexOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult SizeToIndexOp::fold(ArrayRef<Attribute> operands) {
   // Constant values of both types, `shape.size` and `index`, are represented as
   // `IntegerAttr`s which makes constant folding simple.
   if (Attribute arg = operands[0])
     return arg;
   return impl::foldCastOp(*this);
 }
 
 void SizeToIndexOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<IndexToSizeToIndexCanonicalization>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(shape::YieldOp op) {
-  auto *parentOp = op->getParentOp();
+LogicalResult shape::YieldOp::verify() {
+  auto *parentOp = (*this)->getParentOp();
   auto results = parentOp->getResults();
-  auto operands = op.getOperands();
+  auto operands = getOperands();
 
-  if (parentOp->getNumResults() != op.getNumOperands())
-    return op.emitOpError() << "number of operands does not match number of "
-                               "results of its parent";
+  if (parentOp->getNumResults() != getNumOperands())
+    return emitOpError() << "number of operands does not match number of "
   for (auto e : llvm::zip(results, operands))
     if (std::get<0>(e).getType() != std::get<1>(e).getType())
-      return op.emitOpError()
-             << "types mismatch between yield op and its parent";
+      return emitOpError() << "types mismatch between yield op and its parent";
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SplitAtOp
 //===----------------------------------------------------------------------===//
 
void ReduceOp::build(OpBuilder &builder, OperationState &result, Value shape,
   bodyBlock.addArgument(elementType, shape.getLoc());
 
   for (Value initVal : initVals) {
     bodyBlock.addArgument(initVal.getType(), initVal.getLoc());
     result.addTypes(initVal.getType());
   }
 }
 
-static LogicalResult verify(ReduceOp op) {
+LogicalResult ReduceOp::verify() {
   // Verify block arg types.
-  Block &block = op.getRegion().front();
+  Block &block = getRegion().front();
 
   // The block takes index, extent, and aggregated values as arguments.
-  auto blockArgsCount = op.getInitVals().size() + 2;
+  auto blockArgsCount = getInitVals().size() + 2;
   if (block.getNumArguments() != blockArgsCount)
-    return op.emitOpError() << "ReduceOp body is expected to have "
-                            << blockArgsCount << " arguments";
+    return emitOpError() << "ReduceOp body is expected to have "
 
   // The first block argument is the index and must always be of type `index`.
   if (!block.getArgument(0).getType().isa<IndexType>())
-    return op.emitOpError(
+    return emitOpError(
         "argument 0 of ReduceOp body is expected to be of IndexType");
 
   // The second block argument is the extent and must be of type `size` or
   // `index`, depending on whether the reduce operation is applied to a shape or
   // to an extent tensor.
   Type extentTy = block.getArgument(1).getType();
-  if (op.getShape().getType().isa<ShapeType>()) {
+  if (getShape().getType().isa<ShapeType>()) {
     if (!extentTy.isa<SizeType>())
-      return op.emitOpError("argument 1 of ReduceOp body is expected to be of "
-                            "SizeType if the ReduceOp operates on a ShapeType");
+      return emitOpError("argument 1 of ReduceOp body is expected to be of "
   } else {
     if (!extentTy.isa<IndexType>())
-      return op.emitOpError(
+      return emitOpError(
           "argument 1 of ReduceOp body is expected to be of IndexType if the "
           "ReduceOp operates on an extent tensor");
   }
 
-  for (const auto &type : llvm::enumerate(op.getInitVals()))
+  for (const auto &type : llvm::enumerate(getInitVals()))
     if (block.getArgument(type.index() + 2).getType() != type.value().getType())
-      return op.emitOpError()
-             << "type mismatch between argument " << type.index() + 2
-             << " of ReduceOp body and initial value " << type.index();
+      return emitOpError() << "type mismatch between argument "
+                           << type.index() + 2
+                           << " of ReduceOp body and initial value "
+                           << type.index();
   return success();
 }
 
 static ParseResult parseReduceOp(OpAsmParser &parser, OperationState &result) {
   // Parse operands.
   SmallVector<OpAsmParser::OperandType, 3> operands;
   Type shapeOrExtentTensorType;
   if (parser.parseOperandList(operands, /*requiredOperandCount=*/-1,

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

else if (parser.parseColonType(type))
     return failure();
 
   // Add the attribute type to the list.
   return parser.addTypeToList(type, result.types);
 }
 
 /// The constant op requires an attribute, and furthermore requires that it
 /// matches the return type.
-static LogicalResult verify(ConstantOp &op) {
-  auto value = op.getValue();
+LogicalResult ConstantOp::verify() {
+  auto value = getValue();
   if (!value)
-    return op.emitOpError("requires a 'value' attribute");
+    return emitOpError("requires a 'value' attribute");
 
-  Type type = op.getType();
+  Type type = getType();
   if (!value.getType().isa<NoneType>() && type != value.getType())
-    return op.emitOpError() << "requires attribute's type (" << value.getType()
-                            << ") to match op's return type (" << type << ")";
+    return emitOpError() << "requires attribute's type (" << value.getType()
 
   if (type.isa<FunctionType>()) {
     auto fnAttr = value.dyn_cast<FlatSymbolRefAttr>();
     if (!fnAttr)
-      return op.emitOpError("requires 'value' to be a function reference");
+      return emitOpError("requires 'value' to be a function reference");
 
     // Try to find the referenced function.
-    auto fn =
-        op->getParentOfType<ModuleOp>().lookupSymbol<FuncOp>(fnAttr.getValue());
+    auto fn = (*this)->getParentOfType<ModuleOp>().lookupSymbol<FuncOp>(
+        fnAttr.getValue());
     if (!fn)
-      return op.emitOpError()
-             << "reference to undefined function '" << fnAttr.getValue() << "'";
+      return emitOpError() << "reference to undefined function '"
+                           << fnAttr.getValue() << "'";
 
     // Check that the referenced function has the correct type.
     if (fn.getType() != type)
-      return op.emitOpError("reference to function with mismatched type");
+      return emitOpError("reference to function with mismatched type");
 
     return success();
   }
 
   if (type.isa<NoneType>() && value.isa<UnitAttr>())
     return success();
 
-  return op.emitOpError("unsupported 'value' attribute: ") << value;
+  return emitOpError("unsupported 'value' attribute: ") << value;
 }
 
 OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "constant has no operands");
   return getValue();
 }
 
 void ConstantOp::getAsmResultNames(
bool ConstantOp::isBuildableWith(Attribute value, Type type) {
   // Otherwise, this must be a UnitAttr.
   return value.isa<UnitAttr>() && type.isa<NoneType>();
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReturnOp op) {
-  auto function = cast<FuncOp>(op->getParentOp());
+LogicalResult ReturnOp::verify() {
+  auto function = cast<FuncOp>((*this)->getParentOp());
 
   // The operand number and types must match the function signature.
   const auto &results = function.getType().getResults();
-  if (op.getNumOperands() != results.size())
-    return op.emitOpError("has ")
-           << op.getNumOperands() << " operands, but enclosing function (@"
+  if (getNumOperands() != results.size())
+    return emitOpError("has ")
+           << getNumOperands() << " operands, but enclosing function (@"
            << function.getName() << ") returns " << results.size();
 
   for (unsigned i = 0, e = results.size(); i != e; ++i)
-    if (op.getOperand(i).getType() != results[i])
-      return op.emitError()
-             << "type of return operand " << i << " ("
-             << op.getOperand(i).getType()
-             << ") doesn't match function result type (" << results[i] << ")"
+    if (getOperand(i).getType() != results[i])
+      return emitError() << "type of return operand " << i << " ("
+                         << getOperand(i).getType()
+                         << ") doesn't match function result type ("
+                         << results[i] << ")"
                          << " in function @" << function.getName();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
static ParseResult parseSelectOp(OpAsmParser &parser, OperationState &result) {
   }
 
   result.addTypes(resultType);
   return parser.resolveOperands(operands,
                                 {conditionType, resultType, resultType},
                                 parser.getNameLoc(), result.operands);
 }
 
-static LogicalResult verify(SelectOp op) {
-  Type conditionType = op.getCondition().getType();
+LogicalResult SelectOp::verify() {
+  Type conditionType = getCondition().getType();
   if (conditionType.isSignlessInteger(1))
     return success();
 
   // If the result type is a vector or tensor, the type can be a mask with the
   // same elements.
-  Type resultType = op.getType();
+  Type resultType = getType();
   if (!resultType.isa<TensorType, VectorType>())
-    return op.emitOpError()
-           << "expected condition to be a signless i1, but got "
+    return emitOpError() << "expected condition to be a signless i1, but got "
                          << conditionType;
   Type shapedConditionType = getI1SameShape(resultType);
   if (conditionType != shapedConditionType)
-    return op.emitOpError()
-           << "expected condition type to have the same shape "
+    return emitOpError() << "expected condition type to have the same shape "
                             "as the result type, expected "
-           << shapedConditionType << ", but got " << conditionType;
+                         << shapedConditionType << ", but got "
+                         << conditionType;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(SplatOp op) {
+LogicalResult SplatOp::verify() {
   // TODO: we could replace this by a trait.
-  if (op.getOperand().getType() !=
-      op.getType().cast<ShapedType>().getElementType())
-    return op.emitError("operand should be of elemental type of result type");
+  if (getOperand().getType() != getType().cast<ShapedType>().getElementType())
+    return emitError("operand should be of elemental type of result type");
 
   return success();
 }
 
 // Constant folding hook for SplatOp.
 OpFoldResult SplatOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "splat takes one operand");
 
for (const auto &it : llvm::enumerate(caseValues.getValues<APInt>())) {
     p << it.value().getLimitedValue();
     p << ": ";
     p.printSuccessorAndUseList(caseDestinations[it.index()],
                                caseOperands[it.index()]);
   }
   p.printNewline();
 }
 
-static LogicalResult verify(SwitchOp op) {
-  auto caseValues = op.getCaseValues();
-  auto caseDestinations = op.getCaseDestinations();
+LogicalResult SwitchOp::verify() {
+  auto caseValues = getCaseValues();
+  auto caseDestinations = getCaseDestinations();
 
   if (!caseValues && caseDestinations.empty())
     return success();
 
-  Type flagType = op.getFlag().getType();
+  Type flagType = getFlag().getType();
   Type caseValueType = caseValues->getType().getElementType();
   if (caseValueType != flagType)
-    return op.emitOpError()
-           << "'flag' type (" << flagType << ") should match case value type ("
-           << caseValueType << ")";
+    return emitOpError() << "'flag' type (" << flagType
+                         << ") should match case value type (" << caseValueType
+                         << ")";
 
   if (caseValues &&
       caseValues->size() != static_cast<int64_t>(caseDestinations.size()))
-    return op.emitOpError() << "number of case values (" << caseValues->size()
-                            << ") should match number of "
-                               "case destinations ("
-                            << caseDestinations.size() << ")";
+    return emitOpError() << "number of case values (" << caseValues->size()
   return success();
 }
 
 Optional<MutableOperandRange>
 SwitchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
   return index == 0 ? getDefaultOperandsMutable()
                     : getCaseOperandsMutable(index - 1);

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

if ((inputIsQuant && !op.quantization_info()) ||
     op.emitOpError("quantizationattr is required for quantized type, and not "
                    "allowed for float type");
     return failure();
   }
 
   return success();
 }
 
-static LogicalResult verifyAveragePoolOp(tosa::AvgPool2dOp op) {
-  auto inputETy = op.input().getType().cast<ShapedType>().getElementType();
-  auto resultETy = op.getType().cast<ShapedType>().getElementType();
+LogicalResult tosa::AvgPool2dOp::verify() {
+  auto inputETy = input().getType().cast<ShapedType>().getElementType();
+  auto resultETy = getType().cast<ShapedType>().getElementType();
 
   if (auto quantType = inputETy.dyn_cast<mlir::quant::UniformQuantizedType>())
     inputETy = quantType.getStorageType();
 
   if (auto quantType = resultETy.dyn_cast<mlir::quant::UniformQuantizedType>())
     resultETy = quantType.getStorageType();
 
   if (inputETy.isF32() && resultETy.isF32())
     return success();
   if (inputETy.isInteger(8) && resultETy.isInteger(8))
     return success();
   if (inputETy.isInteger(16) && resultETy.isInteger(16))
     return success();
 
-  return op.emitOpError("input/output element types are incompatible.");
+  return emitOpError("input/output element types are incompatible.");
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Quantization Builders.
 //===----------------------------------------------------------------------===//
 
 /// This builder is called on all convolution operators except TransposeConv,
 /// which has specialized output shape semantics. The builder also defines the
outShape[1] = outShape[1] == ShapedType::kDynamicSize
                       ? biasShape.getDimSize(0)
                       : outShape[1];
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
+LogicalResult FullyConnectedOp::verify() { return verifyConvOp(*this); }
+
 LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor lhsShape = operands.getShape(0);
   ShapeAdaptor rhsShape = operands.getShape(1);
 
   // All shapes are dynamic.
if (!ShapedType::isDynamic(inputWidth) &&
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
+LogicalResult Conv2DOp::verify() { return verifyConvOp(*this); }
+
 LogicalResult Conv3DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(5, ShapedType::kDynamicSize);
   Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
if (!ShapedType::isDynamic(inputDepth) &&
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[3] = (unstridedResult - 1) / stride[2] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
+LogicalResult Conv3DOp::verify() { return verifyConvOp(*this); }
+
 LogicalResult AvgPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
if (!ShapedType::isDynamic(inputWidth) &&
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
+LogicalResult DepthwiseConv2DOp::verify() { return verifyConvOp(*this); }
+
 LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   TransposeConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
   llvm::SmallVector<int64_t> outputShape;
   getI64Values(adaptor.out_shape(), outputShape);
 

mlir/lib/IR/BuiltinDialect.cpp

 }
 
 static void print(FuncOp op, OpAsmPrinter &p) {
   FunctionType fnType = op.getType();
   function_interface_impl::printFunctionOp(
       p, op, fnType.getInputs(), /*isVariadic=*/false, fnType.getResults());
 }
 
-static LogicalResult verify(FuncOp op) {
+LogicalResult FuncOp::verify() {
   // If this function is external there is nothing to do.
-  if (op.isExternal())
+  if (isExternal())
     return success();
 
   // Verify that the argument list of the function and the arg list of the entry
   // block line up.  The trait already verified that the number of arguments is
   // the same between the signature and the block.
-  auto fnInputTypes = op.getType().getInputs();
-  Block &entryBlock = op.front();
+  auto fnInputTypes = getType().getInputs();
+  Block &entryBlock = front();
   for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i)
     if (fnInputTypes[i] != entryBlock.getArgument(i).getType())
-      return op.emitOpError("type of entry block argument #")
+      return emitOpError("type of entry block argument #")
              << i << '(' << entryBlock.getArgument(i).getType()
              << ") must match the type of the corresponding argument in "
              << "function signature(" << fnInputTypes[i] << ')';
 
   return success();
 }
 
 /// Clone the internal blocks from this function into dest and all attributes
DataLayoutSpecInterface ModuleOp::getDataLayoutSpec() {
   // interface. This needs a linear search, but is called only once per data
   // layout object construction that is used for repeated queries.
   for (NamedAttribute attr : getOperation()->getAttrs())
     if (auto spec = attr.getValue().dyn_cast<DataLayoutSpecInterface>())
       return spec;
   return {};
 }
 
-static LogicalResult verify(ModuleOp op) {
+LogicalResult ModuleOp::verify() {
   // Check that none of the attributes are non-dialect attributes, except for
   // the symbol related attributes.
-  for (auto attr : op->getAttrs()) {
+  for (auto attr : (*this)->getAttrs()) {
     if (!attr.getName().strref().contains('.') &&
         !llvm::is_contained(
             ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),
                                 mlir::SymbolTable::getVisibilityAttrName()},
             attr.getName().strref()))
-      return op.emitOpError() << "can only contain attributes with "
-                                 "dialect-prefixed names, found: '"
-                              << attr.getName().getValue() << "'";
+      return emitOpError() << "can only contain attributes with "
   }
 
   // Check that there is at most one data layout spec attribute.
   StringRef layoutSpecAttrName;
   DataLayoutSpecInterface layoutSpec;
-  for (const NamedAttribute &na : op->getAttrs()) {
+  for (const NamedAttribute &na : (*this)->getAttrs()) {
     if (auto spec = na.getValue().dyn_cast<DataLayoutSpecInterface>()) {
       if (layoutSpec) {
         InFlightDiagnostic diag =
-            op.emitOpError() << "expects at most one data layout attribute";
+            emitOpError() << "expects at most one data layout attribute";
         diag.attachNote() << "'" << layoutSpecAttrName
                           << "' is a data layout attribute";
         diag.attachNote() << "'" << na.getName().getValue()
                           << "' is a data layout attribute";
       }
       layoutSpecAttrName = na.getName().strref();
       layoutSpec = spec;
     }

mlir/test/mlir-tblgen/op-decl-and-defs.td

def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
   let regions = (region
     AnyRegion:$someRegion,
     VariadicRegion<AnyRegion>:$someRegions
   );
   let builders = [OpBuilder<(ins "Value":$val)>,
                   OpBuilder<(ins CArg<"int", "0">:$integer)>];
   let parser = [{ foo }];
   let printer = [{ bar }];
-  let verifier = [{ baz }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Display a graph for debugging purposes.
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations