[mlir][NFC] Update MemRef/Tensor operations to use `hasVerifier` instead of `verifier`

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

 def MemRefTypeAttr
     : TypeAttrBase<"::mlir::MemRefType", "memref type attribute"> {
   let constBuilderCall = "::mlir::TypeAttr::get($0)";
 }
 
 class MemRef_Op<string mnemonic, list<Trait> traits = []>
     : Op<MemRef_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // AllocLikeOp
 //===----------------------------------------------------------------------===//
 
 // Base class for memref allocating ops: alloca and alloc.
let extraClassDeclaration = [{
     operand_range getDynamicSizes() { return dynamicSizes(); }
   }];
 
   let assemblyFormat = [{
     `(`$dynamicSizes`)` (`` `[` $symbolOperands^ `]`)? attr-dict `:` type($memref)
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AssumeAlignmentOp
 //===----------------------------------------------------------------------===//
 
 def AssumeAlignmentOp : MemRef_Op<"assume_alignment"> {
   let summary =
       "assertion that gives alignment information to the input memref";
   let description = [{
     The `assume_alignment` operation takes a memref and an integer of alignment
     value, and internally annotates the buffer with the given alignment. If
     the buffer isn't aligned to the given alignment, the behavior is undefined.
 
     This operation doesn't affect the semantics of a correct program. It's for
     optimization only, and the optimization is best-effort.
   }];
   let arguments = (ins AnyMemRef:$memref,
                        Confined<I32Attr, [IntPositive]>:$alignment);
   let results = (outs);
 
   let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocOp : AllocLikeOp<"alloc", DefaultResource, []> {
   let summary = "memory allocation operation";
let description = [{
     region of memory that will be indexed is aligned at the specified byte
     boundary.
 
     ```mlir
     %0 = memref.alloc()[%s] {alignment = 8} :
       memref<8x64xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
     ```
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
   let summary = "stack memory allocation operation";
let description = [{
     ```
 
     This operation returns a single SSA value of memref type, which can be used
     by subsequent load and store operations. An optional alignment attribute, if
     specified, guarantees alignment at least to that boundary. If not specified,
     an alignment on any convenient boundary compatible with the type will be
     chosen.
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaScopeOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaScopeOp : MemRef_Op<"alloca_scope",
       [AutomaticAllocationScope,
let description = [{
     ```
 
     If `memref.alloca_scope` returns no value, the `memref.alloca_scope.return ` can
     be left out, and will be inserted implicitly.
   }];
 
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$bodyRegion);
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaScopeReturnOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaScopeReturnOp : MemRef_Op<"alloca_scope.return",
       [HasParent<"AllocaScopeOp">,
let description = [{
     ```mlir
     memref.alloca_scope.return %value
     ```
   }];
 
   let arguments = (ins Variadic<AnyType>:$results);
   let builders = [OpBuilder<(ins), [{ /*nothing to do */ }]>];
 
-  let assemblyFormat =
-      [{ attr-dict ($results^ `:` type($results))? }];
-
-  // No custom verification needed.
-  let verifier = ?;
+  let assemblyFormat = "attr-dict ($results^ `:` type($results))?";
 }
 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_CastOp : MemRef_Op<"cast", [
       NoSideEffect, SameOperandsAndResultShape,
let description = [{
     Erase rank information.
         %5 = memref.cast %1 : memref<4x?xf32> to memref<*xf32>
     ```
   }];
 
   let arguments = (ins AnyRankedOrUnrankedMemRef:$source);
   let results = (outs AnyRankedOrUnrankedMemRef:$dest);
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
-  let verifier = "return impl::verifyCastOp(*this, areCastCompatible);";
   let builders = [
     OpBuilder<(ins "Value":$source, "Type":$destType), [{
        impl::buildCastOp($_builder, $_state, source, destType);
     }]>
   ];
 
   let extraClassDeclaration = [{
     /// Fold the given CastOp into consumer op.
     static bool canFoldIntoConsumerOp(CastOp castOp);
 
     Value getViewSource() { return source(); }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // CopyOp
 //===----------------------------------------------------------------------===//
 
 def CopyOp : MemRef_Op<"copy",
     [CopyOpInterface, SameOperandsElementType, SameOperandsShape]> {
def CopyOp : MemRef_Op<"copy",
   }];
 
   let assemblyFormat = [{
     $source `,` $target attr-dict `:` type($source) `to` type($target)
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_DeallocOp : MemRef_Op<"dealloc", [MemRefsNormalizable]> {
   let summary = "memory deallocation operation";
let description = [{
     %0 = memref.alloc() : memref<8x64xf32, affine_map<(d0, d1) -> (d0, d1), 1>>
     memref.dealloc %0 : memref<8x64xf32,  affine_map<(d0, d1) -> (d0, d1), 1>>
     ```
   }];
 
   let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "", [MemFree]>:$memref);
 
   let hasFolder = 1;
-  let verifier = ?;
   let assemblyFormat = "$memref attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_DimOp : MemRef_Op<"dim", [NoSideEffect, MemRefsNormalizable]> {
def MemRef_DimOp : MemRef_Op<"dim", [NoSideEffect, MemRefsNormalizable]> {
 
   let extraClassDeclaration = [{
     /// Helper function to get the index as a simple integer if it is constant.
     Optional<int64_t> getConstantIndex();
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DmaStartOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_DmaStartOp : MemRef_Op<"dma_start"> {
   let summary = "non-blocking DMA operation that starts a transfer";
let extraClassDeclaration = [{
 
     Value getNumElementsPerStride() {
       if (!isStrided())
         return nullptr;
       return getOperand(getNumOperands() - 1);
     }
   }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DmaWaitOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_DmaWaitOp : MemRef_Op<"dma_wait"> {
   let summary = "blocking DMA operation that waits for transfer completion";
unsigned getTagMemRefRank() {
       return getTagMemRef().getType().cast<MemRefType>().getRank();
     }
 
     /// Returns the number of elements transferred in the associated DMA
     /// operation.
     Value getNumElements() { return numElements(); }
   }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // GenericAtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 def GenericAtomicRMWOp : MemRef_Op<"generic_atomic_rmw", [
       SingleBlockImplicitTerminator<"AtomicYieldOp">,
let extraClassDeclaration = [{
     // The value stored in memref[ivs].
     Value getCurrentValue() {
       return getRegion().getArgument(0);
     }
     MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
     }
   }];
+  let hasVerifier = 1;
 }
 
 def AtomicYieldOp : MemRef_Op<"atomic_yield", [
       HasParent<"GenericAtomicRMWOp">,
       NoSideEffect,
       Terminator
     ]> {
   let summary = "yield operation for GenericAtomicRMWOp";
   let description = [{
     "memref.atomic_yield" yields an SSA value from a
     GenericAtomicRMWOp region.
   }];
 
   let arguments = (ins AnyType:$result);
   let assemblyFormat = "$result attr-dict `:` type($result)";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // GetGlobalOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_GetGlobalOp : MemRef_Op<"get_global",
     [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
let description = [{
      ```mlir
      %x = memref.get_global @foo : memref<2xf32>
      ```
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$name);
   let results = (outs AnyStaticShapeMemRef:$result);
   let assemblyFormat = "$name `:` type($result) attr-dict";
-
-  // `GetGlobalOp` is fully verified by its traits.
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_GlobalOp : MemRef_Op<"global", [Symbol]> {
   let summary = "declare or define a global memref variable";
def MemRef_GlobalOp : MemRef_Op<"global", [Symbol]> {
   }];
 
   let extraClassDeclaration = [{
      bool isExternal() { return !initial_value(); }
      bool isUninitialized() {
        return !isExternal() && initial_value().getValue().isa<UnitAttr>();
      }
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 def LoadOp : MemRef_Op<"load",
      [TypesMatchWith<"result type matches element type of 'memref'",
let extraClassDeclaration = [{
     MemRefType getMemRefType() {
       return getMemRef().getType().cast<MemRefType>();
     }
 
     operand_range getIndices() { return {operand_begin() + 1, operand_end()}; }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let assemblyFormat = "$memref `[` $indices `]` attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
 // PrefetchOp
 //===----------------------------------------------------------------------===//
 
MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
     }
     static StringRef getLocalityHintAttrName() { return "localityHint"; }
     static StringRef getIsWriteAttrName() { return "isWrite"; }
     static StringRef getIsDataCacheAttrName() { return "isDataCache"; }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ReinterpretCastOp:
     BaseOpWithOffsetSizesAndStrides<MemRef_Dialect, "reinterpret_cast", [
let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes) `` `,` `strides`
     `` `:`
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let parser = ?;
   let printer = ?;
+  let hasVerifier = 1;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "OpFoldResult":$offset, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with static entries.
let description = [{
     %0 = memref.rank %arg0 : memref<*xf32>
     %1 = memref.rank %arg1 : memref<?x?xf32>
     ```
   }];
 
   let arguments = (ins AnyRankedOrUnrankedMemRef:$memref);
   let results = (outs Index);
 
-  let verifier = ?;
   let hasFolder = 1;
   let assemblyFormat = "$memref attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
def MemRef_ReshapeOp: MemRef_Op<"reshape", [
   let extraClassDeclaration = [{
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
     Value getViewSource() { return source(); }
   }];
 
   let assemblyFormat = [{
     $source `(` $shape `)` attr-dict `:` functional-type(operands, results)
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
 class MemRef_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     MemRef_Op<mnemonic, !listconcat(traits,
code commonExtraClassDeclaration = [{
     };
     MemRefType getSrcType() { return src().getType().cast<MemRefType>(); }
     MemRefType getResultType() { return result().getType().cast<MemRefType>(); }
     Value getViewSource() { return src(); }
   }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parseReshapeLikeOp(parser, result); }];
 }
 
 def MemRef_ExpandShapeOp : MemRef_ReassociativeReshapeOp<"expand_shape"> {
   let summary = "operation to produce a memref with a higher rank.";
   let description = [{
     The `memref.expand_shape` op produces a new view with a higher rank whose
let description = [{
 
     ```mlir
     // Dimension expansion i -> (i', j') and (k) -> (k')
     %1 = memref.expand_shape %0 [[0, 1], [2]] :
       memref<?x?xf32, stride_spec> into memref<?x?x?xf32, stride_spec_2>
     ```
   }];
   let extraClassDeclaration = commonExtraClassDeclaration;
+  let hasVerifier = 1;
 }
 
 def MemRef_CollapseShapeOp : MemRef_ReassociativeReshapeOp<"collapse_shape"> {
   let summary = "operation to produce a memref with a smaller rank.";
   let description = [{
     The `memref.collapse_shape` op produces a new view with a smaller rank
     whose sizes are a reassociation of the original `view`. Depending on
     whether or not the reassociated MemRefType is contiguous, the resulting
let description = [{
 
     ```mlir
     // Dimension collapse (i, j) -> i' and k -> k'
     %1 = memref.collapse_shape %0 [[0, 1], [2]] :
       memref<?x?x?xf32, stride_spec> into memref<?x?xf32, stride_spec_2>
     ```
   }];
   let extraClassDeclaration = commonExtraClassDeclaration;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_StoreOp : MemRef_Op<"store",
      [TypesMatchWith<"type of 'value' matches element type of 'memref'",
let extraClassDeclaration = [{
       }
 
       operand_range getIndices() {
         return {operand_begin() + 2, operand_end()};
       }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let assemblyFormat = [{
     $value `,` $memref `[` $indices `]` attr-dict `:` type($memref)
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // SubViewOp
let extraClassDeclaration = extraBaseClassDeclaration # [{
 
     /// Return the dimensions of the source type that are dropped when
     /// the result is rank-reduced.
     llvm::SmallDenseSet<unsigned> getDroppedDims();
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TensorStoreOp
 //===----------------------------------------------------------------------===//
 
 def TensorStoreOp : MemRef_Op<"tensor_store",
     [SameOperandsShape, SameOperandsElementType,
let description = [{
     %9 = dim %8, 1 : tensor<4x?xf32>
     %10 = memref.alloc(%9) : memref<4x?xf32, #layout, memspace0>
     memref.tensor_store %8, %10 : memref<4x?xf32, #layout, memspace0>
     ```
   }];
 
   let arguments = (ins AnyTensor:$tensor, Arg<AnyRankedOrUnrankedMemRef,
                        "the reference to store to", [MemWrite]>:$memref);
-  // TensorStoreOp is fully verified by traits.
-  let verifier = ?;
 
   let assemblyFormat = "$tensor `,` $memref attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
OpBuilder<(ins "Value":$in, "AffineMapAttr":$permutation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let extraClassDeclaration = [{
     static StringRef getPermutationAttrName() { return "permutation"; }
     ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ViewOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ViewOp : MemRef_Op<"view", [
     DeclareOpInterfaceMethods<ViewLikeOpInterface>, NoSideEffect]> {
let extraClassDeclaration = [{
     ///                              Region *region)
     /// ```
     operand_range getDynamicSizes() {
       return {sizes().begin(), sizes().end()};
     }
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 def AtomicRMWOp : MemRef_Op<"atomic_rmw", [
       AllTypesMatch<["value", "result"]>,
def AtomicRMWOp : MemRef_Op<"atomic_rmw", [
   }];
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
     }
   }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 #endif // MEMREF_OPS

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 
 //===----------------------------------------------------------------------===//
 // Base class.
 //===----------------------------------------------------------------------===//
 
 class SparseTensor_Op<string mnemonic, list<Trait> traits = []>
   : Op<SparseTensor_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Operations.
 //===----------------------------------------------------------------------===//
 
 def SparseTensor_NewOp : SparseTensor_Op<"new", [NoSideEffect]>,
string description = [{
 
     Example:
 
     ```mlir
     sparse_tensor.new %source : !Source to tensor<1024x1024xf64, #CSR>
     ```
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_InitOp : SparseTensor_Op<"init", [NoSideEffect]>,
     Arguments<(ins Variadic<Index>:$sizes)>,
     Results<(outs AnyTensor:$result)> {
   string summary = "Materializes an unitialized sparse tensor";
   string description = [{
     Materializes an uninitialized sparse tensor with given shape (either static
     or dynamic). The operation is provided as an anchor that materializes a
     properly typed but uninitialized sparse tensor into the output clause of
     a subsequent operation that yields a sparse tensor as the result.
 
     Example:
 
     ```mlir
     %c = sparse_tensor.init_tensor [%d1, %d2] : tensor<?x?xf32, #SparseMatrix>
     %0 = linalg.matmul
       ins(%a, %b: tensor<?x?xf32>, tensor<?x?xf32>)
       outs(%c: tensor<?x?xf32, #SparseMatrix>) -> tensor<?x?xf32, #SparseMatrix>
     ```
   }];
   let assemblyFormat = "`[` $sizes `]` attr-dict `:` type($result)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ConvertOp : SparseTensor_Op<"convert",
   [NoSideEffect, SameOperandsAndResultElementType]>,
     Arguments<(ins AnyTensor:$source)>,
     Results<(outs AnyTensor:$dest)> {
   string summary = "Converts between different tensor types";
   string description = [{
string description = [{
     // The following conversion is not allowed (since it would require a
     // runtime assertion that the source's dimension size is actually 100).
     %4 = sparse_tensor.convert %d : tensor<?xf64> to tensor<100xf64, #SV>
     ```
 
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts pointers array at given dimension from a tensor";
   let description = [{
     Returns the pointers array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     pointers array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.pointers %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts indices array at given dimension from a tensor";
   let description = [{
     Returns the indices array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     indices array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.indices %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts numerical values array from a tensor";
   let description = [{
     Returns the values array of the sparse storage format for the given
     sparse tensor, independent of the actual dimension. This is similar to
     the `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into a call into a support library to obtain access to the
     values array.
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.values %0 : tensor<64x64xf64, #CSR> to memref<?xf64>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Management Operations. These operations are "impure" in the
 // sense that they do not properly operate on SSA values. Instead, the behavior
 // is solely defined by side-effects. These operations provide a bridge between
 // the code generator and the support library. The semantics of these operations
 // may be refined over time as our sparse abstractions evolve.
string description = [{
 
     ```mlir
     sparse_tensor.lex_insert %tensor, %indices, %val
       : tensor<1024x1024xf64, #CSR>, memref<?xindex>, f64
     ```
   }];
   let assemblyFormat = "$tensor `,` $indices `,` $value attr-dict `:`"
                        " type($tensor) `,` type($indices) `,` type($value)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ExpandOp : SparseTensor_Op<"expand", []>,
     Arguments<(ins AnyTensor:$tensor)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$values,
                   StridedMemRefRankOf<[I1],[1]>:$filled,
                   StridedMemRefRankOf<[Index],[1]>:$added,
                   Index:$count)> {
string description = [{
 
     ```mlir
     %values, %filled, %added, %count = sparse_tensor.expand %0
       : tensor<4x4xf64, #CSR> to memref<?xf64>, memref<?xi1>, memref<?xindex>, index
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($values)"
                        " `,` type($filled) `,` type($added) `,` type($count)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_CompressOp : SparseTensor_Op<"compress", []>,
     Arguments<(ins AnyTensor:$tensor,
                    StridedMemRefRankOf<[Index],[1]>:$indices,
                    AnyStridedMemRefOfRank<1>:$values,
                    StridedMemRefRankOf<[I1],[1]>:$filled,
                    StridedMemRefRankOf<[Index],[1]>:$added,
sparse_tensor.compress %0, %1, %values, %filled, %added, %2
         : tensor<4x4xf64, #CSR>, memref<?xindex>, memref<?xf64>,
     memref<?xi1>, memref<?xindex>, index
     ```
   }];
   let assemblyFormat = "$tensor `,` $indices `,` $values `,` $filled `,`"
                         " $added `,` $count attr-dict `:` type($tensor) `,`"
       " type($indices) `,` type($values) `,` type($filled) `,`"
       " type($added) `,` type($count)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
     Arguments<(ins AnyTensor:$tensor, UnitAttr:$hasInserts)>,
     Results<(outs AnyTensor:$result)> {
   let summary =
     "Rematerializes tensor from underlying sparse storage format";
   let description = [{
let description = [{
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.load %0 : tensor<8xf64, #SV>
     ```
   }];
   let assemblyFormat = "$tensor (`hasInserts` $hasInserts^)? attr-dict `:` type($tensor)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
     Arguments<(ins AnyTensor:$tensor)> {
   string summary = "Releases underlying sparse storage format of given tensor";
   string description = [{
     Releases the underlying sparse storage format for a tensor that
     materialized earlier through a `new` operator, `init` operator, or a
string description = [{
 
     Example:
 
     ```mlir
     sparse_tensor.release %tensor : tensor<1024x1024xf64, #CSR>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor)";
+  let hasVerifier = 1;
 }
 
 def SparseTensor_OutOp : SparseTensor_Op<"out", []>,
     Arguments<(ins AnyType:$tensor, AnyType:$dest)> {
   string summary = "Outputs a sparse tensor to the given destination";
   string description = [{
     Outputs the contents of a sparse tensor to the destination defined by an
     opaque pointer provided by `dest`. For targets that have access to a file
     system, for example, this pointer may specify a filename (or file) for output.
     The form of the operation is kept deliberately very general to allow for
     alternative implementations in the future, such as sending the contents to
     a buffer defined by a pointer.
 
     Example:
 
     ```mlir
     sparse_tensor.out %t, %dest : tensor<1024x1024xf64, #CSR>, !Dest
     ```
   }];
   let assemblyFormat = "$tensor `,` $dest attr-dict `:` type($tensor) `,` type($dest)";
+  let hasVerifier = 1;
 }
 
 #endif // SPARSETENSOR_OPS

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/TilingInterface.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 class Tensor_Op<string mnemonic, list<Trait> traits = []>
     : Op<Tensor_Dialect, mnemonic, traits> {
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_CastOp : Tensor_Op<"cast", [
let description = [{
     ```
   }];
 
   let arguments = (ins AnyTensor:$source);
   let results = (outs AnyTensor:$dest);
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
 
   let hasCanonicalizer = 1;
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_DimOp : Tensor_Op<"dim", [NoSideEffect]> {
   let summary = "dimension index operation";
def Tensor_DimOp : Tensor_Op<"dim", [NoSideEffect]> {
 
   let extraClassDeclaration = [{
     /// Helper function to get the index as a simple integer if it is constant.
     Optional<int64_t> getConstantIndex();
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ExtractOp : Tensor_Op<"extract",
     [NoSideEffect,
def Tensor_ExtractOp : Tensor_Op<"extract",
 
   let builders = [
     OpBuilder<(ins "Value":$tensor, CArg<"ValueRange", "{}">:$indices), [{
       auto resType = tensor.getType().cast<ShapedType>().getElementType();
       build($_builder, $_state, resType, tensor, indices);
     }]>];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 
 //===----------------------------------------------------------------------===//
 // ExtractSliceOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ExtractSliceOp : BaseOpWithOffsetSizesAndStrides<
let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Return the dimensions of the source that are dropped in the
     /// result when the result is rank-reduced.
     llvm::SmallDenseSet<unsigned> getDroppedDims();
 
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FromElementsOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_FromElementsOp : Tensor_Op<"from_elements", [
     NoSideEffect,
string description = [{
      [%d, %e, %f]]
   }];
 
   let arguments = (ins Variadic<AnyType>:$elements);
   let results = (outs AnyStaticShapeTensor:$result);
 
   let assemblyFormat = "$elements attr-dict `:` type($result)";
 
-  // This op is fully verified by its traits.
-  let verifier = ?;
-
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "Type":$resultType, "ValueRange":$elements)>,
     // Special case builder for when `elements` has size >=1.
     OpBuilder<(ins "ValueRange":$elements)>
   ];
 
   let hasCanonicalizer = 1;
def Tensor_GenerateOp : Tensor_Op<"generate",
 
   let builders = [
     // Build op and populate its body per callback function.
     OpBuilder<(ins "Type":$resultTy, "ValueRange":$dynamicExtents,
       "function_ref<void(OpBuilder &, Location, ValueRange)>")>,
   ];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_InsertOp : Tensor_Op<"insert",
     [NoSideEffect,
def Tensor_InsertOp : Tensor_Op<"insert",
   let builders = [
     OpBuilder<(ins "Value":$scalar, "Value":$dest,
       CArg<"ValueRange", "{}">:$indices), [{
       auto resType = dest.getType();
       build($_builder, $_state, resType, scalar, dest, indices);
     }]>];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // InsertSliceOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_InsertSliceOp : BaseOpWithOffsetSizesAndStrides<
     Tensor_Dialect, "insert_slice",
let extraClassDeclaration = extraBaseClassDeclaration # [{
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
     static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 2; }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_RankOp : Tensor_Op<"rank", [NoSideEffect]> {
   let summary = "rank operation";
   let description = [{
     The `tensor.rank` operation takes a tensor operand and returns its rank.
 
     Example:
 
     ```mlir
     %0 = tensor.rank %arg0 : tensor<*xf32>
     %1 = tensor.rank %arg1 : tensor<?x?xf32>
     ```
   }];
 
   let arguments = (ins AnyTensor:$tensor);
   let results = (outs Index);
 
-  let verifier = ?;
   let hasFolder = 1;
   let assemblyFormat = "$tensor attr-dict `:` type($tensor)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
def Tensor_ReshapeOp: Tensor_Op<"reshape", [NoSideEffect]>  {
 
   let extraClassDeclaration = [{
     TensorType getResultType() { return getResult().getType().cast<TensorType>(); }
   }];
 
   let assemblyFormat = [{
     $source `(` $shape `)` attr-dict `:` functional-type(operands, results)
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
 class Tensor_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     Tensor_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
code commonExtraClassDeclaration = [{
     }
     RankedTensorType getResultType() {
       return result().getType().cast<RankedTensorType>();
     }
   }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parseReshapeLikeOp(parser, result); }];
 }
 
 def Tensor_ExpandShapeOp : Tensor_ReassociativeReshapeOp<"expand_shape"> {
   let summary = "operation to produce a tensor with a higher rank";
   let description = [{
     The `tensor.expand_shape` op produces a new tensor with a higher
let description = [{
 
     ```mlir
     // Dimension expansion i -> (i', j') and (k) -> (k')
     %b = tensor.expand_shape %a [[0, 1], [2]]
         : tensor<?x?xf32> into tensor<?x?x?xf32>
     ```
   }];
   let extraClassDeclaration = commonExtraClassDeclaration;
+  let hasVerifier = 1;
 }
 
 def Tensor_CollapseShapeOp : Tensor_ReassociativeReshapeOp<"collapse_shape"> {
   let summary = "operation to produce a tensor with a smaller rank";
   let description = [{
     The `tensor.collapse_shape` op produces a new tensor with a smaller
     rank whose sizes are a reassociation of the original `src`.
 
let description = [{
 
     ```mlir
     // Dimension collapse (i, j) -> i' and k -> k'
     %b = tensor.collapse_shape %a [[0, 1], [2]]
         : tensor<?x?x?xf32> into tensor<?x?xf32>
     ```
   }];
   let extraClassDeclaration = commonExtraClassDeclaration;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // PadOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_PadOp : Tensor_Op<"pad", [AttrSizedOperandSegments, NoSideEffect,
     SingleBlockImplicitTerminator<"mlir::tensor::YieldOp">]> {
let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"bool", "false">:$nofold,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_YieldOp : Tensor_Op<"yield",
     [NoSideEffect, ReturnLike, Terminator,
      HasParent<"::mlir::tensor::GenerateOp, ::mlir::tensor::PadOp">]> {
   let summary = "Yield a value from a region";
   let description = [{
      This operation is used to yield a single value from a within a region. It
      is used to create dynamically sized tensors
      (see `tensor.generate` and `tensor.pad` ops).
   }];
 
   let arguments = (ins AnyType:$value);
   let assemblyFormat = "$value attr-dict `:` type($value)";
 
   // Dummy builder to appease code in templated ensureTerminator that
   // GenerateOp's auto-generated parser calls.
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
-  let verifier = ?;
 }
 
 #endif // TENSOR_OPS

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 Type mlir::memref::getTensorTypeFromMemRefType(Type type) {
   if (auto memref = type.dyn_cast<MemRefType>())
     return RankedTensorType::get(memref.getShape(), memref.getElementType());
   if (auto memref = type.dyn_cast<UnrankedMemRefType>())
     return UnrankedTensorType::get(memref.getElementType());
   return NoneType::get(type.getContext());
 }
 
+LogicalResult memref::CastOp::verify() {
+  return impl::verifyCastOp(*this, areCastCompatible);
+}
+
 //===----------------------------------------------------------------------===//
 // AllocOp / AllocaOp
 //===----------------------------------------------------------------------===//
 
 template <typename AllocLikeOp>
 static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
   static_assert(llvm::is_one_of<AllocLikeOp, AllocOp, AllocaOp>::value,
                 "applies to only alloc or alloca");
static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
   if (op.symbolOperands().size() != numSymbols)
     return op.emitOpError("symbol operand count does not equal memref symbol "
                           "count: expected ")
            << numSymbols << ", got " << op.symbolOperands().size();
 
   return success();
 }
 
-static LogicalResult verify(AllocOp op) { return verifyAllocLikeOp(op); }
+LogicalResult AllocOp::verify() { return verifyAllocLikeOp(*this); }
 
-static LogicalResult verify(AllocaOp op) {
+LogicalResult AllocaOp::verify() {
   // An alloca op needs to have an ancestor with an allocation scope trait.
-  if (!op->getParentWithTrait<OpTrait::AutomaticAllocationScope>())
-    return op.emitOpError(
+  if (!(*this)->getParentWithTrait<OpTrait::AutomaticAllocationScope>())
+    return emitOpError(
         "requires an ancestor op with AutomaticAllocationScope trait");
 
-  return verifyAllocLikeOp(op);
+  return verifyAllocLikeOp(*this);
 }
 
 namespace {
 /// Fold constant dimensions into an alloc like operation.
 template <typename AllocLikeOp>
 struct SimplifyAllocConst : public OpRewritePattern<AllocLikeOp> {
   using OpRewritePattern<AllocLikeOp>::OpRewritePattern;
 
static ParseResult parseAllocaScopeOp(OpAsmParser &parser,
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
-static LogicalResult verify(AllocaScopeOp op) {
-  if (failed(RegionBranchOpInterface::verifyTypes(op)))
-    return failure();
-
-  return success();
+LogicalResult AllocaScopeOp::verify() {
+  return RegionBranchOpInterface::verifyTypes(*this);
 }
 
 void AllocaScopeOp::getSuccessorRegions(
     Optional<unsigned> index, ArrayRef<Attribute> operands,
     SmallVectorImpl<RegionSuccessor> &regions) {
   if (index.hasValue()) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
   regions.push_back(RegionSuccessor(&bodyRegion()));
 }
 
 //===----------------------------------------------------------------------===//
 // AssumeAlignmentOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(AssumeAlignmentOp op) {
-  unsigned alignment = op.alignment();
-  if (!llvm::isPowerOf2_32(alignment))
-    return op.emitOpError("alignment must be power of 2");
+LogicalResult AssumeAlignmentOp::verify() {
+  if (!llvm::isPowerOf2_32(alignment()))
+    return emitOpError("alignment must be power of 2");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 /// Determines whether MemRef_CastOp casts to a more dynamic version of the

 }
 
 Optional<int64_t> DimOp::getConstantIndex() {
   if (auto constantOp = index().getDefiningOp<arith::ConstantOp>())
     return constantOp.getValue().cast<IntegerAttr>().getInt();
   return {};
 }
 
-static LogicalResult verify(DimOp op) {
+LogicalResult DimOp::verify() {
   // Assume unknown index to be in range.
-  Optional<int64_t> index = op.getConstantIndex();
+  Optional<int64_t> index = getConstantIndex();
   if (!index.hasValue())
     return success();
 
   // Check that constant index is not knowingly out of range.
-  auto type = op.source().getType();
+  auto type = source().getType();
   if (auto memrefType = type.dyn_cast<MemRefType>()) {
     if (index.getValue() >= memrefType.getRank())
-      return op.emitOpError("index is out of range");
+      return emitOpError("index is out of range");
   } else if (type.isa<UnrankedMemRefType>()) {
     // Assume index to be in range.
   } else {
     llvm_unreachable("expected operand with memref type");
   }
   return success();
 }
 
static ParseResult parseDmaStartOp(OpAsmParser &parser,
   if (isStrided) {
     if (parser.resolveOperands(strideInfo, indexType, result.operands))
       return failure();
   }
 
   return success();
 }
 
-static LogicalResult verify(DmaStartOp op) {
-  unsigned numOperands = op.getNumOperands();
+LogicalResult DmaStartOp::verify() {
+  unsigned numOperands = getNumOperands();
 
   // Mandatory non-variadic operands are: src memref, dst memref, tag memref and
   // the number of elements.
   if (numOperands < 4)
-    return op.emitOpError("expected at least 4 operands");
+    return emitOpError("expected at least 4 operands");
 
   // Check types of operands. The order of these calls is important: the later
   // calls rely on some type properties to compute the operand position.
   // 1. Source memref.
-  if (!op.getSrcMemRef().getType().isa<MemRefType>())
-    return op.emitOpError("expected source to be of memref type");
-  if (numOperands < op.getSrcMemRefRank() + 4)
-    return op.emitOpError()
-           << "expected at least " << op.getSrcMemRefRank() + 4 << " operands";
-  if (!op.getSrcIndices().empty() &&
-      !llvm::all_of(op.getSrcIndices().getTypes(),
+  if (!getSrcMemRef().getType().isa<MemRefType>())
+    return emitOpError("expected source to be of memref type");
+  if (numOperands < getSrcMemRefRank() + 4)
+    return emitOpError() << "expected at least " << getSrcMemRefRank() + 4
+                         << " operands";
+  if (!getSrcIndices().empty() &&
+      !llvm::all_of(getSrcIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))
-    return op.emitOpError("expected source indices to be of index type");
+    return emitOpError("expected source indices to be of index type");
 
   // 2. Destination memref.
-  if (!op.getDstMemRef().getType().isa<MemRefType>())
-    return op.emitOpError("expected destination to be of memref type");
-  unsigned numExpectedOperands =
-      op.getSrcMemRefRank() + op.getDstMemRefRank() + 4;
+  if (!getDstMemRef().getType().isa<MemRefType>())
+    return emitOpError("expected destination to be of memref type");
+  unsigned numExpectedOperands = getSrcMemRefRank() + getDstMemRefRank() + 4;
   if (numOperands < numExpectedOperands)
-    return op.emitOpError()
-           << "expected at least " << numExpectedOperands << " operands";
-  if (!op.getDstIndices().empty() &&
-      !llvm::all_of(op.getDstIndices().getTypes(),
+    return emitOpError() << "expected at least " << numExpectedOperands
+                         << " operands";
+  if (!getDstIndices().empty() &&
+      !llvm::all_of(getDstIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))
-    return op.emitOpError("expected destination indices to be of index type");
+    return emitOpError("expected destination indices to be of index type");
 
   // 3. Number of elements.
-  if (!op.getNumElements().getType().isIndex())
-    return op.emitOpError("expected num elements to be of index type");
+  if (!getNumElements().getType().isIndex())
+    return emitOpError("expected num elements to be of index type");
 
   // 4. Tag memref.
-  if (!op.getTagMemRef().getType().isa<MemRefType>())
-    return op.emitOpError("expected tag to be of memref type");
-  numExpectedOperands += op.getTagMemRefRank();
+  if (!getTagMemRef().getType().isa<MemRefType>())
+    return emitOpError("expected tag to be of memref type");
+  numExpectedOperands += getTagMemRefRank();
   if (numOperands < numExpectedOperands)
-    return op.emitOpError()
-           << "expected at least " << numExpectedOperands << " operands";
-  if (!op.getTagIndices().empty() &&
-      !llvm::all_of(op.getTagIndices().getTypes(),
+    return emitOpError() << "expected at least " << numExpectedOperands
+                         << " operands";
+  if (!getTagIndices().empty() &&
+      !llvm::all_of(getTagIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))
-    return op.emitOpError("expected tag indices to be of index type");
+    return emitOpError("expected tag indices to be of index type");
 
   // Optional stride-related operands must be either both present or both
   // absent.
   if (numOperands != numExpectedOperands &&
       numOperands != numExpectedOperands + 2)
-    return op.emitOpError("incorrect number of operands");
+    return emitOpError("incorrect number of operands");
 
   // 5. Strides.
-  if (op.isStrided()) {
-    if (!op.getStride().getType().isIndex() ||
-        !op.getNumElementsPerStride().getType().isIndex())
-      return op.emitOpError(
+  if (isStrided()) {
+    if (!getStride().getType().isIndex() ||
+        !getNumElementsPerStride().getType().isIndex())
+      return emitOpError(
           "expected stride and num elements per stride to be of type index");
   }
 
   return success();
 }
 
 LogicalResult DmaStartOp::fold(ArrayRef<Attribute> cstOperands,
                                SmallVectorImpl<OpFoldResult> &results) {
   /// dma_start(memrefcast) -> dma_start
   return foldMemRefCast(*this);
 }
 
 // ---------------------------------------------------------------------------
 // DmaWaitOp
 // ---------------------------------------------------------------------------
 
 LogicalResult DmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
                               SmallVectorImpl<OpFoldResult> &results) {
   /// dma_wait(memrefcast) -> dma_wait
   return foldMemRefCast(*this);
 }
 
-static LogicalResult verify(DmaWaitOp op) {
+LogicalResult DmaWaitOp::verify() {
   // Check that the number of tag indices matches the tagMemRef rank.
-  unsigned numTagIndices = op.tagIndices().size();
-  unsigned tagMemRefRank = op.getTagMemRefRank();
+  unsigned numTagIndices = tagIndices().size();
+  unsigned tagMemRefRank = getTagMemRefRank();
   if (numTagIndices != tagMemRefRank)
-    return op.emitOpError() << "expected tagIndices to have the same number of "
-                               "elements as the tagMemRef rank, expected "
-                            << tagMemRefRank << ", but got " << numTagIndices;
+    return emitOpError() << "expected tagIndices to have the same number of "
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GenericAtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,
                                Value memref, ValueRange ivs) {
   result.addOperands(memref);
   result.addOperands(ivs);
 
   if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) {
     Type elementType = memrefType.getElementType();
     result.addTypes(elementType);
 
     Region *bodyRegion = result.addRegion();
     bodyRegion->push_back(new Block());
     bodyRegion->addArgument(elementType, memref.getLoc());
   }
 }
 
-static LogicalResult verify(GenericAtomicRMWOp op) {
-  auto &body = op.getRegion();
+LogicalResult GenericAtomicRMWOp::verify() {
+  auto &body = getRegion();
   if (body.getNumArguments() != 1)
-    return op.emitOpError("expected single number of entry block arguments");
+    return emitOpError("expected single number of entry block arguments");
 
-  if (op.getResult().getType() != body.getArgument(0).getType())
-    return op.emitOpError(
-        "expected block argument of the same type result type");
+  if (getResult().getType() != body.getArgument(0).getType())
+    return emitOpError("expected block argument of the same type result type");
 
   bool hasSideEffects =
       body.walk([&](Operation *nestedOp) {
             if (MemoryEffectOpInterface::hasNoEffect(nestedOp))
               return WalkResult::advance();
             nestedOp->emitError(
                 "body of 'memref.generic_atomic_rmw' should contain "
                 "only operations with no side effects");
static void print(OpAsmPrinter &p, GenericAtomicRMWOp op) {
   p.printRegion(op.getRegion());
   p.printOptionalAttrDict(op->getAttrs());
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicYieldOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(AtomicYieldOp op) {
-  Type parentType = op->getParentOp()->getResultTypes().front();
-  Type resultType = op.result().getType();
+LogicalResult AtomicYieldOp::verify() {
+  Type parentType = (*this)->getParentOp()->getResultTypes().front();
+  Type resultType = result().getType();
   if (parentType != resultType)
-    return op.emitOpError() << "types mismatch between yield op: " << resultType
-                            << " and its parent: " << parentType;
+    return emitOpError() << "types mismatch between yield op: " << resultType
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
 static void printGlobalMemrefOpTypeAndInitialValue(OpAsmPrinter &p, GlobalOp op,
parseGlobalMemrefOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr,
   if (parser.parseAttribute(initialValue, tensorType))
     return failure();
   if (!initialValue.isa<ElementsAttr>())
     return parser.emitError(parser.getNameLoc())
            << "initial value should be a unit or elements attribute";
   return success();
 }
 
-static LogicalResult verify(GlobalOp op) {
-  auto memrefType = op.type().dyn_cast<MemRefType>();
+LogicalResult GlobalOp::verify() {
+  auto memrefType = type().dyn_cast<MemRefType>();
   if (!memrefType || !memrefType.hasStaticShape())
-    return op.emitOpError("type should be static shaped memref, but got ")
-           << op.type();
+    return emitOpError("type should be static shaped memref, but got ")
+           << type();
 
   // Verify that the initial value, if present, is either a unit attribute or
   // an elements attribute.
-  if (op.initial_value().hasValue()) {
-    Attribute initValue = op.initial_value().getValue();
+  if (initial_value().hasValue()) {
+    Attribute initValue = initial_value().getValue();
     if (!initValue.isa<UnitAttr>() && !initValue.isa<ElementsAttr>())
-      return op.emitOpError("initial value should be a unit or elements "
-                            "attribute, but got ")
+      return emitOpError("initial value should be a unit or elements "
              << initValue;
 
     // Check that the type of the initial value is compatible with the type of
     // the global variable.
     if (initValue.isa<ElementsAttr>()) {
       Type initType = initValue.getType();
       Type tensorType = getTensorTypeFromMemRefType(memrefType);
       if (initType != tensorType)
-        return op.emitOpError("initial value expected to be of type ")
+        return emitOpError("initial value expected to be of type ")
                << tensorType << ", but was of type " << initType;
     }
   }
 
-  if (Optional<uint64_t> alignAttr = op.alignment()) {
+  if (Optional<uint64_t> alignAttr = alignment()) {
     uint64_t alignment = alignAttr.getValue();
 
     if (!llvm::isPowerOf2_64(alignment))
-      return op->emitError() << "alignment attribute value " << alignment
-                             << " is not a power of 2";
+      return emitError() << "alignment attribute value " << alignment
   }
 
   // TODO: verify visibility for declarations.
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetGlobalOp
return emitOpError("result type ")
            << " of the global memref @" << name();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(LoadOp op) {
-  if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
-    return op.emitOpError("incorrect number of indices for load");
+LogicalResult LoadOp::verify() {
+  if (getNumOperands() != 1 + getMemRefType().getRank())
+    return emitOpError("incorrect number of indices for load");
   return success();
 }
 
 OpFoldResult LoadOp::fold(ArrayRef<Attribute> cstOperands) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
static ParseResult parsePrefetchOp(OpAsmParser &parser,
 
   result.addAttribute(
       PrefetchOp::getIsDataCacheAttrName(),
       parser.getBuilder().getBoolAttr(cacheType.equals("data")));
 
   return success();
 }
 
-static LogicalResult verify(PrefetchOp op) {
-  if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
-    return op.emitOpError("too few indices");
+LogicalResult PrefetchOp::verify() {
+  if (getNumOperands() != 1 + getMemRefType().getRank())
+    return emitOpError("too few indices");
 
   return success();
 }
 
 LogicalResult PrefetchOp::fold(ArrayRef<Attribute> cstOperands,
                                SmallVectorImpl<OpFoldResult> &results) {
   // prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offset, sizeValues, strideValues, attrs);
 }
 
 // TODO: ponder whether we want to allow missing trailing sizes/strides that are
 // completed automatically, like we have for subview and extract_slice.
-static LogicalResult verify(ReinterpretCastOp op) {
+LogicalResult ReinterpretCastOp::verify() {
   // The source and result memrefs should be in the same memory space.
-  auto srcType = op.source().getType().cast<BaseMemRefType>();
-  auto resultType = op.getType().cast<MemRefType>();
+  auto srcType = source().getType().cast<BaseMemRefType>();
+  auto resultType = getType().cast<MemRefType>();
   if (srcType.getMemorySpace() != resultType.getMemorySpace())
-    return op.emitError("different memory spaces specified for source type ")
+    return emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
-    return op.emitError("different element types specified for source type ")
+    return emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
   // Match sizes in result memref type and in static_sizes attribute.
-  for (auto &en :
-       llvm::enumerate(llvm::zip(resultType.getShape(),
-                                 extractFromI64ArrayAttr(op.static_sizes())))) {
+  for (auto &en : llvm::enumerate(llvm::zip(
+           resultType.getShape(), extractFromI64ArrayAttr(static_sizes())))) {
     int64_t resultSize = std::get<0>(en.value());
     int64_t expectedSize = std::get<1>(en.value());
     if (!ShapedType::isDynamic(resultSize) &&
         !ShapedType::isDynamic(expectedSize) && resultSize != expectedSize)
-      return op.emitError("expected result type with size = ")
+      return emitError("expected result type with size = ")
              << expectedSize << " instead of " << resultSize
              << " in dim = " << en.index();
   }
 
   // Match offset and strides in static_offset and static_strides attributes. If
   // result memref type has no affine map specified, this will assume an
   // identity layout.
   int64_t resultOffset;
   SmallVector<int64_t, 4> resultStrides;
   if (failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
-    return op.emitError(
-               "expected result type to have strided layout but found ")
+    return emitError("expected result type to have strided layout but found ")
            << resultType;
 
   // Match offset in result memref type and in static_offsets attribute.
-  int64_t expectedOffset = extractFromI64ArrayAttr(op.static_offsets()).front();
+  int64_t expectedOffset = extractFromI64ArrayAttr(static_offsets()).front();
   if (!ShapedType::isDynamicStrideOrOffset(resultOffset) &&
       !ShapedType::isDynamicStrideOrOffset(expectedOffset) &&
       resultOffset != expectedOffset)
-    return op.emitError("expected result type with offset = ")
+    return emitError("expected result type with offset = ")
            << resultOffset << " instead of " << expectedOffset;
 
   // Match strides in result memref type and in static_strides attribute.
   for (auto &en : llvm::enumerate(llvm::zip(
-           resultStrides, extractFromI64ArrayAttr(op.static_strides())))) {
+           resultStrides, extractFromI64ArrayAttr(static_strides())))) {
     int64_t resultStride = std::get<0>(en.value());
     int64_t expectedStride = std::get<1>(en.value());
     if (!ShapedType::isDynamicStrideOrOffset(resultStride) &&
         !ShapedType::isDynamicStrideOrOffset(expectedStride) &&
         resultStride != expectedStride)
-      return op.emitError("expected result type with stride = ")
+      return emitError("expected result type with stride = ")
              << expectedStride << " instead of " << resultStride
              << " in dim = " << en.index();
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
static LogicalResult verifyReshapeOp(ReshapeOp op, MemRefType expandedType,
   auto maps = op.getReassociationMaps();
   MemRefType expectedType = computeReshapeCollapsedType(expandedType, maps);
   if (collapsedType != expectedType)
     return op.emitOpError("expected collapsed type to be ")
            << expectedType << ", but got " << collapsedType;
   return success();
 }
 
-static LogicalResult verify(ExpandShapeOp op) {
-  return verifyReshapeOp(op, op.getResultType(), op.getSrcType());
+LogicalResult ExpandShapeOp::verify() {
+  return verifyReshapeOp(*this, getResultType(), getSrcType());
 }
 
 void ExpandShapeOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                 MLIRContext *context) {
   results.add<CollapseReshapeOps<ExpandShapeOp>,
               CollapseMixedReshapeOps<ExpandShapeOp, CollapseShapeOp>>(context);
 }
 
-static LogicalResult verify(CollapseShapeOp op) {
-  return verifyReshapeOp(op, op.getSrcType(), op.getResultType());
+LogicalResult CollapseShapeOp::verify() {
+  return verifyReshapeOp(*this, getSrcType(), getResultType());
 }
 
 struct CollapseShapeOpMemRefCastFolder
     : public OpRewritePattern<CollapseShapeOp> {
 public:
   using OpRewritePattern<CollapseShapeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CollapseShapeOp op,

 OpFoldResult CollapseShapeOp::fold(ArrayRef<Attribute> operands) {
   return foldReshapeOp<CollapseShapeOp, ExpandShapeOp>(*this, operands);
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReshapeOp op) {
-  Type operandType = op.source().getType();
-  Type resultType = op.result().getType();
+LogicalResult ReshapeOp::verify() {
+  Type operandType = source().getType();
+  Type resultType = result().getType();
 
   Type operandElementType = operandType.cast<ShapedType>().getElementType();
   Type resultElementType = resultType.cast<ShapedType>().getElementType();
   if (operandElementType != resultElementType)
-    return op.emitOpError("element types of source and destination memref "
-                          "types should be the same");
+    return emitOpError("element types of source and destination memref "
 
   if (auto operandMemRefType = operandType.dyn_cast<MemRefType>())
     if (!operandMemRefType.getLayout().isIdentity())
-      return op.emitOpError(
-          "source memref type should have identity affine map");
+      return emitOpError("source memref type should have identity affine map");
 
-  int64_t shapeSize = op.shape().getType().cast<MemRefType>().getDimSize(0);
+  int64_t shapeSize = shape().getType().cast<MemRefType>().getDimSize(0);
   auto resultMemRefType = resultType.dyn_cast<MemRefType>();
   if (resultMemRefType) {
     if (!resultMemRefType.getLayout().isIdentity())
-      return op.emitOpError(
-          "result memref type should have identity affine map");
+      return emitOpError("result memref type should have identity affine map");
     if (shapeSize == ShapedType::kDynamicSize)
-      return op.emitOpError("cannot use shape operand with dynamic length to "
-                            "reshape to statically-ranked memref type");
+      return emitOpError("cannot use shape operand with dynamic length to "
     if (shapeSize != resultMemRefType.getRank())
-      return op.emitOpError(
+      return emitOpError(
           "length of shape operand differs from the result's memref rank");
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(StoreOp op) {
-  if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
-    return op.emitOpError("store index operand count not equal to memref rank");
+LogicalResult StoreOp::verify() {
+  if (getNumOperands() != 2 + getMemRefType().getRank())
+    return emitOpError("store index operand count not equal to memref rank");
 
   return success();
 }
 
 LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
                             SmallVectorImpl<OpFoldResult> &results) {
   /// store(memrefcast) -> store
   return foldMemRefCast(*this, getValueToStore());
case SliceVerificationResult::LayoutMismatch:
     return op.emitError("expected result type to be ")
            << expectedType
            << " or a rank-reduced version. (mismatch of result layout) ";
   }
   llvm_unreachable("unexpected subview verification result");
 }
 
 /// Verifier for SubViewOp.
-static LogicalResult verify(SubViewOp op) {
-  MemRefType baseType = op.getSourceType();
-  MemRefType subViewType = op.getType();
+LogicalResult SubViewOp::verify() {
+  MemRefType baseType = getSourceType();
+  MemRefType subViewType = getType();
 
   // The base memref and the view memref should be in the same memory space.
   if (baseType.getMemorySpace() != subViewType.getMemorySpace())
-    return op.emitError("different memory spaces specified for base memref "
-                        "type ")
+    return emitError("different memory spaces specified for base memref "
            << baseType << " and subview memref type " << subViewType;
 
   // Verify that the base memref type has a strided layout map.
   if (!isStrided(baseType))
-    return op.emitError("base type ") << baseType << " is not strided";
+    return emitError("base type ") << baseType << " is not strided";
 
   // Verify result type against inferred type.
   auto expectedType = SubViewOp::inferResultType(
-      baseType, extractFromI64ArrayAttr(op.static_offsets()),
-      extractFromI64ArrayAttr(op.static_sizes()),
-      extractFromI64ArrayAttr(op.static_strides()));
+      baseType, extractFromI64ArrayAttr(static_offsets()),
+      extractFromI64ArrayAttr(static_sizes()),
+      extractFromI64ArrayAttr(static_strides()));
 
   auto result = isRankReducedMemRefType(expectedType.cast<MemRefType>(),
-                                        subViewType, op.getMixedSizes());
-  return produceSubViewErrorMsg(result, op, expectedType);
+                                        subViewType, getMixedSizes());
+  return produceSubViewErrorMsg(result, *this, expectedType);
 }
 
 raw_ostream &mlir::operator<<(raw_ostream &os, const Range &range) {
   return os << "range " << range.offset << ":" << range.size << ":"
             << range.stride;
 }
 
 /// Return the list of Range (i.e. offset, size, stride). Each Range
if (parser.parseOperand(in) || parser.parseAffineMap(permutation) ||
       parser.addTypeToList(dstType, result.types))
     return failure();
 
   result.addAttribute(TransposeOp::getPermutationAttrName(),
                       AffineMapAttr::get(permutation));
   return success();
 }
 
-static LogicalResult verify(TransposeOp op) {
-  if (!op.permutation().isPermutation())
-    return op.emitOpError("expected a permutation map");
-  if (op.permutation().getNumDims() != op.getShapedType().getRank())
-    return op.emitOpError(
-        "expected a permutation map of same rank as the input");
-
-  auto srcType = op.in().getType().cast<MemRefType>();
-  auto dstType = op.getType().cast<MemRefType>();
-  auto transposedType = inferTransposeResultType(srcType, op.permutation());
+LogicalResult TransposeOp::verify() {
+  if (!permutation().isPermutation())
+    return emitOpError("expected a permutation map");
+  if (permutation().getNumDims() != getShapedType().getRank())
+    return emitOpError("expected a permutation map of same rank as the input");
+
+  auto srcType = in().getType().cast<MemRefType>();
+  auto dstType = getType().cast<MemRefType>();
+  auto transposedType = inferTransposeResultType(srcType, permutation());
   if (dstType != transposedType)
-    return op.emitOpError("output type ")
+    return emitOpError("output type ")
            << dstType << " does not match transposed input type " << srcType
            << ", " << transposedType;
   return success();
 }
 
 OpFoldResult TransposeOp::fold(ArrayRef<Attribute>) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();

 static void print(OpAsmPrinter &p, ViewOp op) {
   p << ' ' << op.getOperand(0) << '[';
   p.printOperand(op.byte_shift());
   p << "][" << op.sizes() << ']';
   p.printOptionalAttrDict(op->getAttrs());
   p << " : " << op.getOperand(0).getType() << " to " << op.getType();
 }
 
-static LogicalResult verify(ViewOp op) {
-  auto baseType = op.getOperand(0).getType().cast<MemRefType>();
-  auto viewType = op.getType();
+LogicalResult ViewOp::verify() {
+  auto baseType = getOperand(0).getType().cast<MemRefType>();
+  auto viewType = getType();
 
   // The base memref should have identity layout map (or none).
   if (!baseType.getLayout().isIdentity())
-    return op.emitError("unsupported map for base memref type ") << baseType;
+    return emitError("unsupported map for base memref type ") << baseType;
 
   // The result memref should have identity layout map (or none).
   if (!viewType.getLayout().isIdentity())
-    return op.emitError("unsupported map for result memref type ") << viewType;
+    return emitError("unsupported map for result memref type ") << viewType;
 
   // The base memref and the view memref should be in the same memory space.
   if (baseType.getMemorySpace() != viewType.getMemorySpace())
-    return op.emitError("different memory spaces specified for base memref "
-                        "type ")
+    return emitError("different memory spaces specified for base memref "
            << baseType << " and view memref type " << viewType;
 
   // Verify that we have the correct number of sizes for the result type.
   unsigned numDynamicDims = viewType.getNumDynamicDims();
-  if (op.sizes().size() != numDynamicDims)
-    return op.emitError("incorrect number of size operands for type ")
-           << viewType;
+  if (sizes().size() != numDynamicDims)
+    return emitError("incorrect number of size operands for type ") << viewType;
 
   return success();
 }
 
 Value ViewOp::getViewSource() { return source(); }
 
 namespace {
 
void ViewOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                          MLIRContext *context) {
   results.add<ViewOpShapeFolder, ViewOpMemrefCastFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicRMWOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(AtomicRMWOp op) {
-  if (op.getMemRefType().getRank() != op.getNumOperands() - 2)
-    return op.emitOpError(
+LogicalResult AtomicRMWOp::verify() {
+  if (getMemRefType().getRank() != getNumOperands() - 2)
+    return emitOpError(
         "expects the number of subscripts to be equal to memref rank");
-  switch (op.kind()) {
+  switch (kind()) {
   case arith::AtomicRMWKind::addf:
   case arith::AtomicRMWKind::maxf:
   case arith::AtomicRMWKind::minf:
   case arith::AtomicRMWKind::mulf:
-    if (!op.value().getType().isa<FloatType>())
-      return op.emitOpError()
-             << "with kind '" << arith::stringifyAtomicRMWKind(op.kind())
+    if (!value().getType().isa<FloatType>())
+      return emitOpError() << "with kind '"
+                           << arith::stringifyAtomicRMWKind(kind())
                            << "' expects a floating-point type";
     break;
   case arith::AtomicRMWKind::addi:
   case arith::AtomicRMWKind::maxs:
   case arith::AtomicRMWKind::maxu:
   case arith::AtomicRMWKind::mins:
   case arith::AtomicRMWKind::minu:
   case arith::AtomicRMWKind::muli:
   case arith::AtomicRMWKind::ori:
   case arith::AtomicRMWKind::andi:
-    if (!op.value().getType().isa<IntegerType>())
-      return op.emitOpError()
-             << "with kind '" << arith::stringifyAtomicRMWKind(op.kind())
+    if (!value().getType().isa<IntegerType>())
+      return emitOpError() << "with kind '"
+                           << arith::stringifyAtomicRMWKind(kind())
                            << "' expects an integer type";
     break;
   default:
     break;
   }
   return success();
 }
 
 OpFoldResult AtomicRMWOp::fold(ArrayRef<Attribute> operands) {

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

 
 static LogicalResult isMatchingWidth(Value result, unsigned width) {
   Type etp = result.getType().cast<MemRefType>().getElementType();
   if ((width == 0 && etp.isIndex()) || (width > 0 && etp.isInteger(width)))
     return success();
   return failure();
 }
 
-static LogicalResult verify(NewOp op) {
-  if (!getSparseTensorEncoding(op.result().getType()))
-    return op.emitError("expected a sparse tensor result");
+LogicalResult NewOp::verify() {
+  if (!getSparseTensorEncoding(result().getType()))
+    return emitError("expected a sparse tensor result");
   return success();
 }
 
-static LogicalResult verify(InitOp op) {
-  if (!getSparseTensorEncoding(op.result().getType()))
-    return op.emitError("expected a sparse tensor result");
-  RankedTensorType ttp = op.getType().cast<RankedTensorType>();
+LogicalResult InitOp::verify() {
+  if (!getSparseTensorEncoding(result().getType()))
+    return emitError("expected a sparse tensor result");
+  RankedTensorType ttp = getType().cast<RankedTensorType>();
   unsigned rank = ttp.getRank();
-  if (rank != op.sizes().size())
-    return op.emitError("unexpected mismatch between tensor rank and sizes: ")
-           << rank << " vs. " << op.sizes().size();
+  if (rank != sizes().size())
+    return emitError("unexpected mismatch between tensor rank and sizes: ")
+           << rank << " vs. " << sizes().size();
   auto shape = ttp.getShape();
   for (unsigned i = 0; i < rank; i++) {
     if (shape[i] == ShapedType::kDynamicSize)
       continue;
     IntegerAttr constantAttr;
-    if (!matchPattern(op.sizes()[i], m_Constant(&constantAttr)) ||
+    if (!matchPattern(sizes()[i], m_Constant(&constantAttr)) ||
         constantAttr.getInt() != shape[i]) {
-      return op.emitError("unexpected mismatch with static dimension size ")
+      return emitError("unexpected mismatch with static dimension size ")
              << shape[i];
     }
   }
   return success();
 }
 
-static LogicalResult verify(ConvertOp op) {
-  if (auto tp1 = op.source().getType().dyn_cast<RankedTensorType>()) {
-    if (auto tp2 = op.dest().getType().dyn_cast<RankedTensorType>()) {
+LogicalResult ConvertOp::verify() {
+  if (auto tp1 = source().getType().dyn_cast<RankedTensorType>()) {
+    if (auto tp2 = dest().getType().dyn_cast<RankedTensorType>()) {
       if (tp1.getRank() != tp2.getRank())
-        return op.emitError("unexpected conversion mismatch in rank");
+        return emitError("unexpected conversion mismatch in rank");
       auto shape1 = tp1.getShape();
       auto shape2 = tp2.getShape();
       // Accept size matches between the source and the destination type
       // (e.g. 10 vs. 10, 10 vs. ?, or ? vs. ?), but reject direct mismatches or
       // matches that would need a runtime assert (e.g. 10 vs. 20 or ? vs. 10).
-      for (unsigned d = 0, rank = tp1.getRank(); d < rank; d++) {
+      for (unsigned d = 0, rank = tp1.getRank(); d < rank; d++)
         if (shape1[d] != shape2[d] && shape2[d] != ShapedType::kDynamicSize)
-          return op.emitError("unexpected conversion mismatch in dimension ")
-                 << d;
-      }
+          return emitError("unexpected conversion mismatch in dimension ") << d;
       return success();
     }
   }
-  return op.emitError("unexpected type in convert");
+  return emitError("unexpected type in convert");
 }
 
 OpFoldResult ConvertOp::fold(ArrayRef<Attribute> operands) {
   if (getType() == source().getType())
     return source();
   return {};
 }
 
-static LogicalResult verify(ToPointersOp op) {
-  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
-    if (failed(isInBounds(op.dim(), op.tensor())))
-      return op.emitError("requested pointers dimension out of bounds");
-    if (failed(isMatchingWidth(op.result(), e.getPointerBitWidth())))
-      return op.emitError("unexpected type for pointers");
+LogicalResult ToPointersOp::verify() {
+  if (auto e = getSparseTensorEncoding(tensor().getType())) {
+    if (failed(isInBounds(dim(), tensor())))
+      return emitError("requested pointers dimension out of bounds");
+    if (failed(isMatchingWidth(result(), e.getPointerBitWidth())))
+      return emitError("unexpected type for pointers");
     return success();
   }
-  return op.emitError("expected a sparse tensor to get pointers");
+  return emitError("expected a sparse tensor to get pointers");
 }
 
-static LogicalResult verify(ToIndicesOp op) {
-  if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
-    if (failed(isInBounds(op.dim(), op.tensor())))
-      return op.emitError("requested indices dimension out of bounds");
-    if (failed(isMatchingWidth(op.result(), e.getIndexBitWidth())))
-      return op.emitError("unexpected type for indices");
+LogicalResult ToIndicesOp::verify() {
+  if (auto e = getSparseTensorEncoding(tensor().getType())) {
+    if (failed(isInBounds(dim(), tensor())))
+      return emitError("requested indices dimension out of bounds");
+    if (failed(isMatchingWidth(result(), e.getIndexBitWidth())))
+      return emitError("unexpected type for indices");
     return success();
   }
-  return op.emitError("expected a sparse tensor to get indices");
+  return emitError("expected a sparse tensor to get indices");
 }
 
-static LogicalResult verify(ToValuesOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor to get values");
-  RankedTensorType ttp = op.tensor().getType().cast<RankedTensorType>();
-  MemRefType mtp = op.result().getType().cast<MemRefType>();
+LogicalResult ToValuesOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor to get values");
+  RankedTensorType ttp = tensor().getType().cast<RankedTensorType>();
+  MemRefType mtp = result().getType().cast<MemRefType>();
   if (ttp.getElementType() != mtp.getElementType())
-    return op.emitError("unexpected mismatch in element types");
+    return emitError("unexpected mismatch in element types");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TensorDialect Management Operations.
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(LexInsertOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor for insertion");
+LogicalResult LexInsertOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor for insertion");
   return success();
 }
 
-static LogicalResult verify(ExpandOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor for expansion");
+LogicalResult ExpandOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor for expansion");
   return success();
 }
 
-static LogicalResult verify(CompressOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor for compression");
+LogicalResult CompressOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor for compression");
   return success();
 }
 
-static LogicalResult verify(LoadOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor to materialize");
+LogicalResult LoadOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor to materialize");
   return success();
 }
 
-static LogicalResult verify(ReleaseOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor to release");
+LogicalResult ReleaseOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor to release");
   return success();
 }
 
-static LogicalResult verify(OutOp op) {
-  if (!getSparseTensorEncoding(op.tensor().getType()))
-    return op.emitError("expected a sparse tensor for output");
+LogicalResult OutOp::verify() {
+  if (!getSparseTensorEncoding(tensor().getType()))
+    return emitError("expected a sparse tensor for output");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TensorDialect Methods.
 //===----------------------------------------------------------------------===//
 
 void SparseTensorDialect::initialize() {

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 }
 
 Optional<int64_t> DimOp::getConstantIndex() {
   if (auto constantOp = index().getDefiningOp<arith::ConstantOp>())
     return constantOp.getValue().cast<IntegerAttr>().getInt();
   return {};
 }
 
-static LogicalResult verify(DimOp op) {
+LogicalResult DimOp::verify() {
   // Assume unknown index to be in range.
-  Optional<int64_t> index = op.getConstantIndex();
+  Optional<int64_t> index = getConstantIndex();
   if (!index.hasValue())
     return success();
 
   // Check that constant index is not knowingly out of range.
-  auto type = op.source().getType();
+  auto type = source().getType();
   if (auto tensorType = type.dyn_cast<RankedTensorType>()) {
     if (index.getValue() >= tensorType.getRank())
-      return op.emitOpError("index is out of range");
+      return emitOpError("index is out of range");
   } else if (type.isa<UnrankedTensorType>()) {
     // Assume index to be in range.
   } else {
     llvm_unreachable("expected operand with tensor type");
   }
   return success();
 }
 
void DimOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<DimOfCastOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ExtractOp op) {
+LogicalResult ExtractOp::verify() {
   // Verify the # indices match if we have a ranked type.
-  if (auto tensorType = op.tensor().getType().dyn_cast<RankedTensorType>())
-    if (tensorType.getRank() != static_cast<int64_t>(op.indices().size()))
-      return op.emitOpError("incorrect number of indices for extract_element");
+  if (auto tensorType = tensor().getType().dyn_cast<RankedTensorType>())
+    if (tensorType.getRank() != static_cast<int64_t>(indices().size()))
+      return emitOpError("incorrect number of indices for extract_element");
 
   return success();
 }
 
 OpFoldResult ExtractOp::fold(ArrayRef<Attribute> operands) {
   // The tensor operand must be a known constant.
   Attribute tensor = operands.front();
   if (!tensor)
results
       .add<ExtractElementFromIndexCast, ExtractElementFromTensorFromElements>(
           context);
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(InsertOp op) {
+LogicalResult InsertOp::verify() {
   // Verify the # indices match if we have a ranked type.
-  if (auto destType = op.dest().getType().dyn_cast<RankedTensorType>())
-    if (destType.getRank() != static_cast<int64_t>(op.indices().size()))
-      return op.emitOpError("incorrect number of indices");
+  if (auto destType = dest().getType().dyn_cast<RankedTensorType>())
+    if (destType.getRank() != static_cast<int64_t>(indices().size()))
+      return emitOpError("incorrect number of indices");
   return success();
 }
 
 OpFoldResult InsertOp::fold(ArrayRef<Attribute> operands) {
   Attribute scalar = operands[0];
   Attribute dest = operands[1];
   if (scalar && dest)
     if (auto splatDest = dest.dyn_cast<SplatElementsAttr>())
       if (scalar == splatDest.getSplatValue<Attribute>())
         return dest;
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // GenerateOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(GenerateOp op) {
+LogicalResult GenerateOp::verify() {
   // Ensure that the tensor type has as many dynamic dimensions as are specified
   // by the operands.
-  RankedTensorType resultTy = op.getType().cast<RankedTensorType>();
-  if (op.getNumOperands() != resultTy.getNumDynamicDims())
-    return op.emitError("must have as many index operands as dynamic extents "
-                        "in the result type");
+  RankedTensorType resultTy = getType().cast<RankedTensorType>();
+  if (getNumOperands() != resultTy.getNumDynamicDims())
+    return emitError("must have as many index operands as dynamic extents "
 
   // Ensure that region arguments span the index space.
-  if (!llvm::all_of(op.body().getArgumentTypes(),
+  if (!llvm::all_of(body().getArgumentTypes(),
                     [](Type ty) { return ty.isIndex(); }))
-    return op.emitError("all body arguments must be index");
-  if (op.body().getNumArguments() != resultTy.getRank())
-    return op.emitError("must have one body argument per input dimension");
+    return emitError("all body arguments must be index");
+  if (body().getNumArguments() != resultTy.getRank())
+    return emitError("must have one body argument per input dimension");
 
   // Ensure that the region yields an element of the right type.
-  auto yieldOp =
-      llvm::cast<YieldOp>(op.body().getBlocks().front().getTerminator());
+  auto yieldOp = cast<YieldOp>(body().getBlocks().front().getTerminator());
 
   if (yieldOp.value().getType() != resultTy.getElementType())
-    return op.emitOpError(
+    return emitOpError(
         "body must be terminated with a `yield` operation of the tensor "
         "element type");
 
   return success();
 }
 
 void GenerateOp::build(
     OpBuilder &b, OperationState &result, Type resultTy,

 
 static int64_t getNumElements(ShapedType type) {
   int64_t numElements = 1;
   for (auto dim : type.getShape())
     numElements *= dim;
   return numElements;
 }
 
-static LogicalResult verify(ReshapeOp op) {
-  TensorType operandType = op.source().getType().cast<TensorType>();
-  TensorType resultType = op.result().getType().cast<TensorType>();
+LogicalResult ReshapeOp::verify() {
+  TensorType operandType = source().getType().cast<TensorType>();
+  TensorType resultType = result().getType().cast<TensorType>();
 
   if (operandType.getElementType() != resultType.getElementType())
-    return op.emitOpError("element types of source and destination tensor "
-                          "types should be the same");
+    return emitOpError("element types of source and destination tensor "
 
-  int64_t shapeSize =
-      op.shape().getType().cast<RankedTensorType>().getDimSize(0);
+  int64_t shapeSize = shape().getType().cast<RankedTensorType>().getDimSize(0);
   auto resultRankedType = resultType.dyn_cast<RankedTensorType>();
   auto operandRankedType = operandType.dyn_cast<RankedTensorType>();
 
   if (resultRankedType) {
     if (operandRankedType && resultRankedType.hasStaticShape() &&
         operandRankedType.hasStaticShape()) {
       if (getNumElements(operandRankedType) != getNumElements(resultRankedType))
-        return op.emitOpError("source and destination tensor should have the "
-                              "same number of elements");
+        return emitOpError("source and destination tensor should have the "
     }
     if (ShapedType::isDynamic(shapeSize))
-      return op.emitOpError("cannot use shape operand with dynamic length to "
-                            "reshape to statically-ranked tensor type");
+      return emitOpError("cannot use shape operand with dynamic length to "
     if (shapeSize != resultRankedType.getRank())
-      return op.emitOpError(
+      return emitOpError(
           "length of shape operand differs from the result's tensor rank");
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Reassociative reshape ops
 //===----------------------------------------------------------------------===//
static LogicalResult verifyTensorReshapeOp(TensorReshapeOp op,
   RankedTensorType expectedType =
       computeTensorReshapeCollapsedType(expandedType, maps);
   if (collapsedType != expectedType)
     return op.emitOpError("expected collapsed type to be ")
            << expectedType << ", but got " << collapsedType;
   return success();
 }
 
-static LogicalResult verify(ExpandShapeOp op) {
-  return verifyTensorReshapeOp(op, op.getResultType(), op.getSrcType());
+LogicalResult ExpandShapeOp::verify() {
+  return verifyTensorReshapeOp(*this, getResultType(), getSrcType());
 }
 
-static LogicalResult verify(CollapseShapeOp op) {
-  return verifyTensorReshapeOp(op, op.getSrcType(), op.getResultType());
+LogicalResult CollapseShapeOp::verify() {
+  return verifyTensorReshapeOp(*this, getSrcType(), getResultType());
 }
 
 namespace {
 /// Reshape of a splat constant can be replaced with a constant of the result
 /// type.
 template <typename TensorReshapeOp>
 struct FoldReshapeWithConstant : OpRewritePattern<TensorReshapeOp> {
   using OpRewritePattern<TensorReshapeOp>::OpRewritePattern;
case SliceVerificationResult::ElemTypeMismatch:
     return op.emitError("expected element type to be ")
            << memrefType.getElementType();
   default:
     llvm_unreachable("unexpected extract_slice op verification result");
   }
 }
 
 /// Verifier for ExtractSliceOp.
-static LogicalResult verify(ExtractSliceOp op) {
+LogicalResult ExtractSliceOp::verify() {
   // Verify result type against inferred type.
-  auto expectedType =
-      ExtractSliceOp::inferResultType(op.getSourceType(), op.getMixedOffsets(),
-                                      op.getMixedSizes(), op.getMixedStrides());
-  auto result =
-      isRankReducedType(expectedType.cast<ShapedType>(), op.getType());
-  return produceSliceErrorMsg(result, op, expectedType);
+  auto expectedType = ExtractSliceOp::inferResultType(
+      getSourceType(), getMixedOffsets(), getMixedSizes(), getMixedStrides());
+  auto result = isRankReducedType(expectedType.cast<ShapedType>(), getType());
+  return produceSliceErrorMsg(result, *this, expectedType);
 }
 
 /// Infer the canonical type of the result of an extract_slice op. Returns a
 /// type with rank `resultRank` that is either the rank of the rank-reduced
 /// type, or the non-rank-reduced type.
 static RankedTensorType
 getCanonicalSliceResultType(unsigned resultRank, RankedTensorType sourceType,
                             ArrayRef<OpFoldResult> mixedOffsets,
void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }
 
 /// Verifier for InsertSliceOp.
-static LogicalResult verify(InsertSliceOp op) {
+LogicalResult InsertSliceOp::verify() {
   // insert_slice is the inverse of extract_slice, use the same type inference.
   auto expectedType = ExtractSliceOp::inferRankReducedResultType(
-      op.getSourceType().getRank(), op.getType(),
-      extractFromI64ArrayAttr(op.static_offsets()),
-      extractFromI64ArrayAttr(op.static_sizes()),
-      extractFromI64ArrayAttr(op.static_strides()));
+      getSourceType().getRank(), getType(),
+      extractFromI64ArrayAttr(static_offsets()),
+      extractFromI64ArrayAttr(static_sizes()),
+      extractFromI64ArrayAttr(static_strides()));
   auto result =
-      isRankReducedType(expectedType.cast<ShapedType>(), op.getSourceType());
-  return produceSliceErrorMsg(result, op, expectedType);
+      isRankReducedType(expectedType.cast<ShapedType>(), getSourceType());
+  return produceSliceErrorMsg(result, *this, expectedType);
 }
 
 /// If we have two consecutive InsertSliceOp writing to the same slice, we
 /// can mutate the second InsertSliceOp's destination to the first one's.
 ///
 /// Example:
 ///
 /// ```mlir

 ParseResult parseInferType(OpAsmParser &parser,
                            Optional<OpAsmParser::OperandType> optOperand,
                            Type &typeToInfer, Type typeToInferFrom) {
   if (optOperand)
     typeToInfer = typeToInferFrom;
   return success();
 }
 
-static LogicalResult verify(PadOp op) {
-  auto sourceType = op.source().getType().cast<RankedTensorType>();
-  auto resultType = op.result().getType().cast<RankedTensorType>();
-  auto expectedType = PadOp::inferResultType(
-      sourceType, extractFromI64ArrayAttr(op.static_low()),
-      extractFromI64ArrayAttr(op.static_high()));
+LogicalResult PadOp::verify() {
+  auto sourceType = source().getType().cast<RankedTensorType>();
+  auto resultType = result().getType().cast<RankedTensorType>();
+  auto expectedType =
+      PadOp::inferResultType(sourceType, extractFromI64ArrayAttr(static_low()),
+                             extractFromI64ArrayAttr(static_high()));
   for (int i = 0, e = sourceType.getRank(); i < e; ++i) {
     if (resultType.getDimSize(i) == expectedType.getDimSize(i))
       continue;
     if (expectedType.isDynamicDim(i))
       continue;
-    return op.emitError("specified type ")
+    return emitError("specified type ")
            << resultType << " does not match the inferred type "
            << expectedType;
   }
 
-  auto &region = op.region();
+  auto &region = getRegion();
   unsigned rank = resultType.getRank();
   Block &block = region.front();
   if (block.getNumArguments() != rank)
-    return op.emitError("expected the block to have ") << rank << " arguments";
+    return emitError("expected the block to have ") << rank << " arguments";
 
   // Note: the number and type of yield values are checked in the YieldOp.
   for (const auto &en : llvm::enumerate(block.getArgumentTypes())) {
     if (!en.value().isIndex())
-      return op.emitOpError("expected block argument ")
+      return emitOpError("expected block argument ")
              << (en.index() + 1) << " to be an index";
   }
 
   // Ensure that the region yields an element of the right type.
   auto yieldOp = llvm::cast<YieldOp>(block.getTerminator());
   if (yieldOp.value().getType() !=
-      op.getType().cast<ShapedType>().getElementType())
-    return op.emitOpError("expected yield type to match shape element type");
+      getType().cast<ShapedType>().getElementType())
+    return emitOpError("expected yield type to match shape element type");
 
   return success();
 }
 
 RankedTensorType PadOp::inferResultType(RankedTensorType sourceType,
                                         ArrayRef<int64_t> staticLow,
                                         ArrayRef<int64_t> staticHigh,
                                         ArrayRef<int64_t> resultShape) {