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

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

def Vector_Dialect : Dialect {
   let dependentDialects = ["arith::ArithmeticDialect"];
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<Trait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits> {
   // For every vector op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
-  //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 // The "kind" of combining function for contractions and reductions.
 def COMBINING_KIND_ADD : BitEnumAttrCaseBit<"ADD", 0, "add">;
 def COMBINING_KIND_MUL : BitEnumAttrCaseBit<"MUL", 1, "mul">;
 def COMBINING_KIND_MINUI : BitEnumAttrCaseBit<"MINUI", 2, "minui">;
 def COMBINING_KIND_MINSI : BitEnumAttrCaseBit<"MINSI", 3, "minsi">;
let extraClassDeclaration = [{
     static constexpr StringRef getKindAttrName() { return "kind"; }
 
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ReductionOp :
   Vector_Op<"reduction", [NoSideEffect,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins StrAttr:$kind, AnyVector:$vector, Variadic<AnyType>:$acc)>,
     Results<(outs AnyType:$dest)> {
let description = [{
     %4 = vector.reduction "mul", %0, %1 : vector<16xf32> into f32
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_MultiDimReductionOp :
   Vector_Op<"multi_reduction", [NoSideEffect,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins Vector_CombiningKindAttr:$kind,
                    AnyVector:$source,
static Type inferDestType(
       if (targetShape.empty())
         return elementType;
       return VectorType::get(targetShape, elementType);
     }
   }];
   let assemblyFormat =
     "$kind `,` $source attr-dict $reduction_dims `:` type($source) `to` type($dest)";
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_BroadcastOp :
   Vector_Op<"broadcast", [NoSideEffect,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyType:$source)>,
     Results<(outs AnyVectorOfAnyRank:$vector)> {
let extraClassDeclaration = [{
     Type getSourceType() { return source().getType(); }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($vector)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ShuffleOp :
   Vector_Op<"shuffle", [NoSideEffect,
      PredOpTrait<"first operand v1 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      PredOpTrait<"second operand v2 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 1>>]>,
let extraClassDeclaration = [{
     }
     VectorType getV2VectorType() {
       return v2().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_ExtractElementOp :
   Vector_Op<"extractelement", [NoSideEffect,
      TypesMatchWith<"result type matches element type of vector operand",
                     "vector", "result",
                     "$_self.cast<ShapedType>().getElementType()">]>,
     Arguments<(ins AnyVectorOfAnyRank:$vector,
let builders = [
     // 1-D + position builder.
     OpBuilder<(ins "Value":$source, "Value":$position)>,
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_ExtractOp :
   Vector_Op<"extract", [NoSideEffect,
      PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$position)>,
     Results<(outs AnyType)> {
def Vector_ExtractOp :
   let extraClassDeclaration = [{
     static StringRef getPositionAttrName() { return "position"; }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ExtractMapOp :
   Vector_Op<"extract_map", [NoSideEffect]>,
     Arguments<(ins AnyVector:$vector, Variadic<Index>:$ids)>,
     Results<(outs AnyVector)> {
   let summary = "vector extract map operation";
   let description = [{
let extraClassDeclaration = [{
     void getMultiplicity(SmallVectorImpl<int64_t> &multiplicity);
     AffineMap map();
   }];
   let assemblyFormat = [{
     $vector `[` $ids `]` attr-dict `:` type($vector) `to` type(results)
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_FMAOp :
   Op<Vector_Dialect, "fma", [
        NoSideEffect, AllTypesMatch<["lhs", "rhs", "acc", "result"]>,
        DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>
      ] # ElementwiseMappable.traits>,
     Arguments<(ins AnyVector:$lhs, AnyVector:$rhs, AnyVector:$acc)>,
let description = [{
     to the `llvm.fma.*` intrinsic.
 
     Example:
 
     ```mlir
     %3 = vector.fma %0, %1, %2: vector<8x16xf32>
     ```
   }];
-  // Fully specified by traits.
-  let verifier = ?;
   let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)";
   let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs, "Value":$acc),
     [{build($_builder, $_state, lhs.getType(), lhs, rhs, acc);}]>
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() { return lhs().getType().cast<VectorType>(); }
   }];
let builders = [
     OpBuilder<(ins "Value":$source, "Value":$dest, "Value":$position)>
   ];
   let extraClassDeclaration = [{
     Type getSourceType() { return source().getType(); }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
   }];
-
+  let hasVerifier = 1;
 }
 
 def Vector_InsertOp :
   Vector_Op<"insert", [NoSideEffect,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      AllTypesMatch<["dest", "res"]>]>,
      Arguments<(ins AnyType:$source, AnyVector:$dest, I64ArrayAttr:$position)>,
let extraClassDeclaration = [{
     Type getSourceType() { return source().getType(); }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_InsertMapOp :
   Vector_Op<"insert_map", [NoSideEffect, AllTypesMatch<["dest", "result"]>]>,
     Arguments<(ins AnyVector:$vector, AnyVector:$dest, Variadic<Index>:$ids)>,
     Results<(outs AnyVector:$result)> {
   let summary = "vector insert map operation";
   let description = [{
let extraClassDeclaration = [{
     }
     // Return a map indicating the dimension mapping to the given ids.
     AffineMap map();
   }];
   let assemblyFormat = [{
     $vector `,` $dest `[` $ids `]` attr-dict
       `:` type($vector) `into` type($result)
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_InsertStridedSliceOp :
   Vector_Op<"insert_strided_slice", [NoSideEffect,
     PredOpTrait<"operand #0 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
     AllTypesMatch<["dest", "res"]>]>,
     Arguments<(ins AnyVector:$source, AnyVector:$dest, I64ArrayAttr:$offsets,
let extraClassDeclaration = [{
     bool hasNonUnitStrides() { 
       return llvm::any_of(strides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_OuterProductOp :
   Vector_Op<"outerproduct", [NoSideEffect,
     PredOpTrait<"lhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 0>>,
     PredOpTrait<"rhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 1>>]>,
let extraClassDeclaration = [{
     }
     static constexpr StringRef getKindAttrName() {
       return "kind";
     }
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
   }];
+  let hasVerifier = 1;
 }
 
 // TODO: Add transformation which decomposes ReshapeOp into an optimized
 // sequence of vector rotate/shuffle/select operations.
 def Vector_ReshapeOp :
   Vector_Op<"reshape", [AttrSizedOperandSegments, NoSideEffect]>,
     Arguments<(ins AnyVector:$vector, Variadic<Index>:$input_shape,
                Variadic<Index>:$output_shape,
let extraClassDeclaration = [{
     static StringRef getInputShapeAttrName() { return "input_shape"; }
     static StringRef getOutputShapeAttrName() { return "output_shape"; }
   }];
 
   let assemblyFormat = [{
     $vector `,` `[` $input_shape `]` `,` `[` $output_shape `]` `,`
     $fixed_vector_sizes attr-dict `:` type($vector) `to` type($result)
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_ExtractStridedSliceOp :
   Vector_Op<"extract_strided_slice", [NoSideEffect,
     PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$offsets,
                I64ArrayAttr:$sizes, I64ArrayAttr:$strides)>,
let extraClassDeclaration = [{
     bool hasNonUnitStrides() { 
       return llvm::any_of(strides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
   let assemblyFormat = "$vector attr-dict `:` type($vector) `to` type(results)";
 }
 
 def Vector_TransferReadOp :
   Vector_Op<"transfer_read", [
       DeclareOpInterfaceMethods<VectorTransferOpInterface>,
       DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>,
       DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
let builders = [
     /// 'getMinorIdentityMap'.
     OpBuilder<(ins "VectorType":$vectorType,
                    "Value":$source,
                    "ValueRange":$indices,
                    CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
   ];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_TransferWriteOp :
   Vector_Op<"transfer_write", [
       DeclareOpInterfaceMethods<VectorTransferOpInterface>,
       DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>,
       DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
       AttrSizedOperandSegments
let builders = [
     /// map to 'getMinorIdentityMap'.
     OpBuilder<(ins "Value":$vector,
                    "Value":$dest,
                    "ValueRange":$indices,
                    CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
   ];
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_LoadOp : Vector_Op<"load"> {
   let summary = "reads an n-D slice of memory into an n-D vector";
   let description = [{
     The 'vector.load' operation reads an n-D slice of memory into an n-D
     vector. It takes a 'base' memref, an index for each memref dimension and a
     result vector type as arguments. It returns a value of the result vector
let extraClassDeclaration = [{
     }
 
     VectorType getVectorType() {
       return result().getType().cast<VectorType>();
     }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let assemblyFormat =
       "$base `[` $indices `]` attr-dict `:` type($base) `,` type($result)";
 }
 
 def Vector_StoreOp : Vector_Op<"store"> {
   let summary = "writes an n-D vector to an n-D slice of memory";
   let description = [{
let extraClassDeclaration = [{
     }
 
     VectorType getVectorType() {
       return valueToStore().getType().cast<VectorType>();
     }
   }];
 
   let hasFolder = 1;
+  let hasVerifier = 1;
 
   let assemblyFormat = "$valueToStore `,` $base `[` $indices `]` attr-dict "
                        "`:` type($base) `,` type($valueToStore)";
 }
 
 def Vector_MaskedLoadOp :
   Vector_Op<"maskedload">,
     Arguments<(ins Arg<AnyMemRef, "", [MemRead]>:$base,
let extraClassDeclaration = [{
     VectorType getVectorType() {
       return result().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$base `[` $indices `]` `,` $mask `,` $pass_thru attr-dict `:` "
     "type($base) `,` type($mask) `,` type($pass_thru) `into` type($result)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_MaskedStoreOp :
   Vector_Op<"maskedstore">,
     Arguments<(ins Arg<AnyMemRef, "", [MemWrite]>:$base,
                Variadic<Index>:$indices,
                VectorOfRankAndType<[1], [I1]>:$mask,
                VectorOfRank<[1]>:$valueToStore)> {
VectorType getVectorType() {
       return valueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `,` $mask `,` $valueToStore "
       "attr-dict `:` type($base) `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_GatherOp :
   Vector_Op<"gather">,
     Arguments<(ins Arg<AnyMemRef, "", [MemRead]>:$base,
                Variadic<Index>:$indices,
          VectorOfRankAndType<[1], [AnyInteger, Index]>:$index_vec,
                VectorOfRankAndType<[1], [I1]>:$mask,
let extraClassDeclaration = [{
     }
   }];
   let assemblyFormat =
     "$base `[` $indices `]` `[` $index_vec `]` `,` "
     "$mask `,` $pass_thru attr-dict `:` type($base) `,` "
     "type($index_vec)  `,` type($mask) `,` type($pass_thru) "
     "`into` type($result)";
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ScatterOp :
   Vector_Op<"scatter">,
     Arguments<(ins Arg<AnyMemRef, "", [MemWrite]>:$base,
                Variadic<Index>:$indices,
          VectorOfRankAndType<[1], [AnyInteger, Index]>:$index_vec,
                VectorOfRankAndType<[1], [I1]>:$mask,
VectorType getVectorType() {
       return valueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `[` $index_vec `]` `,` "
       "$mask `,` $valueToStore attr-dict `:` type($base) `,` "
       "type($index_vec)  `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ExpandLoadOp :
   Vector_Op<"expandload">,
     Arguments<(ins Arg<AnyMemRef, "", [MemRead]>:$base,
                Variadic<Index>:$indices,
                VectorOfRankAndType<[1], [I1]>:$mask,
                VectorOfRank<[1]>:$pass_thru)>,
let extraClassDeclaration = [{
     }
     VectorType getVectorType() {
       return result().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$base `[` $indices `]` `,` $mask `,` $pass_thru attr-dict `:` "
     "type($base) `,` type($mask) `,` type($pass_thru) `into` type($result)";
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_CompressStoreOp :
   Vector_Op<"compressstore">,
     Arguments<(ins Arg<AnyMemRef, "", [MemWrite]>:$base,
                Variadic<Index>:$indices,
                VectorOfRankAndType<[1], [I1]>:$mask,
                VectorOfRank<[1]>:$valueToStore)> {
let extraClassDeclaration = [{
     VectorType getVectorType() {
       return valueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `,` $mask `,` $valueToStore attr-dict `:` "
       "type($base) `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_ShapeCastOp :
   Vector_Op<"shape_cast", [NoSideEffect]>,
     Arguments<(ins AnyVector:$source)>,
     Results<(outs AnyVector:$result)> {
   let summary = "shape_cast casts between vector shapes";
   let description = [{
let extraClassDeclaration = [{
     }
     VectorType getResultVectorType() {
       return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_BitCastOp :
   Vector_Op<"bitcast", [NoSideEffect, AllRanksMatch<["source", "result"]>]>,
     Arguments<(ins AnyVectorOfAnyRank:$source)>,
     Results<(outs AnyVectorOfAnyRank:$result)>{
   let summary = "bitcast casts between vectors";
   let description = [{
VectorType getSourceVectorType() {
       return source().getType().cast<VectorType>();
     }
     VectorType getResultVectorType() {
       return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_TypeCastOp :
   Vector_Op<"type_cast", [NoSideEffect, ViewLikeOpInterface]>,
     Arguments<(ins StaticShapeMemRefOf<[AnyType]>:$memref)>,
     Results<(outs AnyMemRef:$result)> {
   let summary = "type_cast op converts a scalar memref to a vector memref";
   let description = [{
let extraClassDeclaration = [{
     }
     // Implement ViewLikeOpInterface.
     Value getViewSource() { return memref(); }
   }];
 
   let assemblyFormat = [{
     $memref attr-dict `:` type($memref) `to` type($result)
   }];
+  let hasVerifier = 1;
 }
 
 def Vector_ConstantMaskOp :
   Vector_Op<"constant_mask", [NoSideEffect]>,
     Arguments<(ins I64ArrayAttr:$mask_dim_sizes)>,
     Results<(outs VectorOfAnyRankOf<[I1]>)> {
   let summary = "creates a constant vector mask";
   let description = [{
print %1
             3 | 0    0    0
     ```
   }];
 
   let extraClassDeclaration = [{
     static StringRef getMaskDimSizesAttrName() { return "mask_dim_sizes"; }
   }];
   let assemblyFormat = "$mask_dim_sizes attr-dict `:` type(results)";
+  let hasVerifier = 1;
 }
 
 def Vector_CreateMaskOp :
   Vector_Op<"create_mask", [NoSideEffect]>,
     Arguments<(ins Variadic<Index>:$operands)>,
     Results<(outs VectorOfAnyRankOf<[I1]>)> {
   let summary = "creates a vector mask";
   let description = [{
print %1
             0 | 1    1    0
       rows  1 | 1    1    0
             2 | 1    1    0
             3 | 0    0    0
     ```
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
   let assemblyFormat = "$operands attr-dict `:` type(results)";
 }
 
 def Vector_TransposeOp :
   Vector_Op<"transpose", [NoSideEffect,
     PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$transp)>,
let extraClassDeclaration = [{
     void getTransp(SmallVectorImpl<int64_t> &results);
     static StringRef getTranspAttrName() { return "transp"; }
   }];
   let assemblyFormat = [{
     $vector `,` $transp attr-dict `:` type($vector) `to` type($result)
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def Vector_PrintOp :
   Vector_Op<"print", []>, Arguments<(ins AnyType:$source)> {
   let summary = "print operation (for testing and debugging)";
   let description = [{
     Prints the source vector (or scalar) to stdout in human readable
     format (for testing and debugging). No return value.
let description = [{
     ( 0.0, 0.0, 0.0, 0.0 )
 
     on stdout when linked with a small runtime support library,
     which only needs to provide a few printing methods (single
     value for all data types, opening/closing bracket, comma,
     newline).
     ```
   }];
-  let verifier = ?;
   let extraClassDeclaration = [{
     Type getPrintType() {
       return source().getType();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source)";
 }
 
[{
      $_state.addOperands({lhs, rhs});
      $_state.addAttribute("lhs_rows",$_builder.getI32IntegerAttr(lhsRows));
      $_state.addAttribute("lhs_columns",$_builder.getI32IntegerAttr(lhsColumns));
      $_state.addAttribute("rhs_columns",$_builder.getI32IntegerAttr(rhsColumns));
      $_state.addTypes(VectorType::get(lhsRows * rhsColumns,
        lhs.getType().cast<VectorType>().getElementType()));
    }]>,
   ];
-  let verifier = ?;
   let assemblyFormat = "$lhs `,` $rhs attr-dict "
     "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
 }
 
 /// Vector dialect matrix tranposition op that operates on flattened 1-D
 /// MLIR vectors. This is the counterpart of llvm.matrix.transpose in MLIR.
 /// This may seem redundant with vector.transpose but it serves the purposes of
 /// more progressive lowering and localized type conversion on the path:
let description = [{
 
     Example:
 
     ```mlir
     %1 = vector.flat_transpose %0 { rows = 4: i32, columns = 4: i32 }
        : (vector<16xf32>) -> vector<16xf32>
     ```
   }];
-  let verifier = ?;
   let assemblyFormat = "$matrix attr-dict `:` type($matrix) `->` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // VectorScaleOp
 //===----------------------------------------------------------------------===//
 
 // TODO: In the future, we might want to have scalable vectors with different
let description = [{
     `vector<[4]xi32>` is equivalent to performing that operation `vscale`
     times, once on each `<4xi32>` segment of the scalable vector. The `vscale`
     op can be used to calculate the step in vector-length agnostic (VLA) loops.
     Right now we only support one contiguous set of scalable dimensions, all of
     them grouped and scaled with the value returned by 'vscale'.
   }];
   let results = (outs Index:$res);
   let assemblyFormat = "attr-dict";
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // VectorScanOp
 //===----------------------------------------------------------------------===//
 
 def Vector_ScanOp :
   Vector_Op<"scan", [NoSideEffect,
let extraClassDeclaration = [{
     }
     VectorType getInitialValueType() {
       return initial_value().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
     "$kind `,` $source `,` $initial_value attr-dict `:` "
     "type($source) `,` type($initial_value) ";
+  let hasVerifier = 1;
 }
 
 #endif // VECTOR_OPS

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

for (const auto &en : llvm::enumerate(reductionMask))
     if (en.value())
       reductionDims.push_back(en.index());
   result.addAttribute(getReductionDimsAttrName(),
                       builder.getI64ArrayAttr(reductionDims));
   result.addAttribute(getKindAttrName(),
                       CombiningKindAttr::get(kind, builder.getContext()));
 }
 
-static LogicalResult verify(MultiDimReductionOp op) {
-  auto reductionMask = op.getReductionMask();
+LogicalResult MultiDimReductionOp::verify() {
+  auto reductionMask = getReductionMask();
   auto targetType = MultiDimReductionOp::inferDestType(
-      op.getSourceVectorType().getShape(), reductionMask,
-      op.getSourceVectorType().getElementType());
+      getSourceVectorType().getShape(), reductionMask,
+      getSourceVectorType().getElementType());
   // TODO: update to support 0-d vectors when available.
-  if (targetType != op.getDestType())
-    return op.emitError("invalid output vector type: ")
-           << op.getDestType() << " (expected: " << targetType << ")";
+  if (targetType != getDestType())
+    return emitError("invalid output vector type: ")
+           << getDestType() << " (expected: " << targetType << ")";
   return success();
 }
 
 OpFoldResult MultiDimReductionOp::fold(ArrayRef<Attribute> operands) {
   // Single parallel dim, this is a noop.
   if (getSourceVectorType().getRank() == 1 && !isReducedDim(0))
     return source();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // ReductionOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReductionOp op) {
+LogicalResult ReductionOp::verify() {
   // Verify for 1-D vector.
-  int64_t rank = op.getVectorType().getRank();
+  int64_t rank = getVectorType().getRank();
   if (rank != 1)
-    return op.emitOpError("unsupported reduction rank: ") << rank;
+    return emitOpError("unsupported reduction rank: ") << rank;
 
   // Verify supported reduction kind.
-  StringRef strKind = op.kind();
+  StringRef strKind = kind();
   auto maybeKind = symbolizeCombiningKind(strKind);
   if (!maybeKind)
-    return op.emitOpError("unknown reduction kind: ") << strKind;
+    return emitOpError("unknown reduction kind: ") << strKind;
 
-  Type eltType = op.dest().getType();
+  Type eltType = dest().getType();
   if (!isSupportedCombiningKind(*maybeKind, eltType))
-    return op.emitOpError("unsupported reduction type '")
-           << eltType << "' for kind '" << op.kind() << "'";
+    return emitOpError("unsupported reduction type '")
+           << eltType << "' for kind '" << strKind << "'";
 
   // Verify optional accumulator.
-  if (!op.acc().empty()) {
+  if (!acc().empty()) {
     if (strKind != "add" && strKind != "mul")
-      return op.emitOpError("no accumulator for reduction kind: ") << strKind;
+      return emitOpError("no accumulator for reduction kind: ") << strKind;
     if (!eltType.isa<FloatType>())
-      return op.emitOpError("no accumulator for type: ") << eltType;
+      return emitOpError("no accumulator for type: ") << eltType;
   }
 
   return success();
 }
 
 static ParseResult parseReductionOp(OpAsmParser &parser,
                                     OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> operandsInfo;
if (expectedResultDims.empty()) {
     if (resVectorType != expected || accVectorType != expected)
       return op.emitOpError(
                  "invalid accumulator/result vector shape, expected: ")
              << expected;
   }
   return success();
 }
 
-static LogicalResult verify(ContractionOp op) {
-  auto lhsType = op.getLhsType();
-  auto rhsType = op.getRhsType();
-  auto accType = op.getAccType();
-  auto resType = op.getResultType();
+LogicalResult ContractionOp::verify() {
+  auto lhsType = getLhsType();
+  auto rhsType = getRhsType();
+  auto accType = getAccType();
+  auto resType = getResultType();
 
   // Verify that an indexing map was specified for each vector operand.
-  if (op.indexing_maps().size() != 3)
-    return op.emitOpError("expected an indexing map for each vector operand");
+  if (indexing_maps().size() != 3)
+    return emitOpError("expected an indexing map for each vector operand");
 
   // Verify that each index map has 'numIterators' inputs, no symbols, and
   // that the number of map outputs equals the rank of its associated
   // vector operand.
-  unsigned numIterators = op.iterator_types().getValue().size();
-  for (const auto &it : llvm::enumerate(op.indexing_maps())) {
+  unsigned numIterators = iterator_types().getValue().size();
+  for (const auto &it : llvm::enumerate(indexing_maps())) {
     auto index = it.index();
     auto map = it.value().cast<AffineMapAttr>().getValue();
     if (map.getNumSymbols() != 0)
-      return op.emitOpError("expected indexing map ")
+      return emitOpError("expected indexing map ")
              << index << " to have no symbols";
-    auto vectorType = op.getOperand(index).getType().dyn_cast<VectorType>();
+    auto vectorType = getOperand(index).getType().dyn_cast<VectorType>();
     unsigned rank = vectorType ? vectorType.getShape().size() : 0;
     // Verify that the map has the right number of inputs, outputs, and indices.
     // This also correctly accounts for (..) -> () for rank-0 results.
     if (map.getNumDims() != numIterators)
-      return op.emitOpError("expected indexing map ")
+      return emitOpError("expected indexing map ")
              << index << " to have " << numIterators << " number of inputs";
     if (map.getNumResults() != rank)
-      return op.emitOpError("expected indexing map ")
+      return emitOpError("expected indexing map ")
              << index << " to have " << rank << " number of outputs";
     if (!map.isProjectedPermutation())
-      return op.emitOpError("expected indexing map ")
+      return emitOpError("expected indexing map ")
              << index << " to be a projected permutation of its inputs";
   }
 
-  auto contractingDimMap = op.getContractingDimMap();
-  auto batchDimMap = op.getBatchDimMap();
+  auto contractingDimMap = getContractingDimMap();
+  auto batchDimMap = getBatchDimMap();
 
   // Verify at least one contracting dimension pair was specified.
   if (contractingDimMap.empty())
-    return op.emitOpError("expected at least one contracting dimension pair");
+    return emitOpError("expected at least one contracting dimension pair");
 
   // Verify contracting dimension map was properly constructed.
   if (!verifyDimMap(lhsType, rhsType, contractingDimMap))
-    return op.emitOpError("invalid contracting dimension map");
+    return emitOpError("invalid contracting dimension map");
 
   // Verify batch dimension map was properly constructed.
   if (!verifyDimMap(lhsType, rhsType, batchDimMap))
-    return op.emitOpError("invalid batch dimension map");
+    return emitOpError("invalid batch dimension map");
 
   // Verify 'accType' and 'resType' shape.
-  if (failed(verifyOutputShape(op, lhsType, rhsType, accType, resType,
+  if (failed(verifyOutputShape(*this, lhsType, rhsType, accType, resType,
                                contractingDimMap, batchDimMap)))
     return failure();
 
   // Verify that either two vector masks are set or none are set.
-  auto lhsMaskType = op.getLHSVectorMaskType();
-  auto rhsMaskType = op.getRHSVectorMaskType();
+  auto lhsMaskType = getLHSVectorMaskType();
+  auto rhsMaskType = getRHSVectorMaskType();
   if ((lhsMaskType && !rhsMaskType) || (!lhsMaskType && rhsMaskType))
-    return op.emitOpError("invalid number of vector masks specified");
+    return emitOpError("invalid number of vector masks specified");
   if (lhsMaskType && rhsMaskType) {
     // Verify mask rank == argument rank.
     if (lhsMaskType.getShape().size() != lhsType.getShape().size() ||
         rhsMaskType.getShape().size() != rhsType.getShape().size())
-      return op.emitOpError("invalid vector mask rank");
+      return emitOpError("invalid vector mask rank");
   }
 
   // Verify supported combining kind.
   auto vectorType = resType.dyn_cast<VectorType>();
   auto elementType = vectorType ? vectorType.getElementType() : resType;
-  if (!isSupportedCombiningKind(op.kind(), elementType))
-    return op.emitOpError("unsupported contraction type");
+  if (!isSupportedCombiningKind(kind(), elementType))
+    return emitOpError("unsupported contraction type");
 
   return success();
 }
 
 ArrayRef<StringRef> ContractionOp::getTraitAttrNames() {
   static constexpr StringRef names[3] = {getIndexingMapsAttrName(),
                                          getIteratorTypesAttrName(),
                                          ContractionOp::getKindAttrName()};

 }
 
 void vector::ExtractElementOp::build(OpBuilder &builder, OperationState &result,
                                      Value source, Value position) {
   result.addOperands({source, position});
   result.addTypes(source.getType().cast<VectorType>().getElementType());
 }
 
-static LogicalResult verify(vector::ExtractElementOp op) {
-  VectorType vectorType = op.getVectorType();
+LogicalResult vector::ExtractElementOp::verify() {
+  VectorType vectorType = getVectorType();
   if (vectorType.getRank() == 0) {
-    if (op.position())
-      return op.emitOpError("expected position to be empty with 0-D vector");
+    if (position())
+      return emitOpError("expected position to be empty with 0-D vector");
     return success();
   }
   if (vectorType.getRank() != 1)
-    return op.emitOpError("unexpected >1 vector rank");
-  if (!op.position())
-    return op.emitOpError("expected position for 1-D vector");
+    return emitOpError("unexpected >1 vector rank");
+  if (!position())
+    return emitOpError("expected position for 1-D vector");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 
 static Type inferExtractOpResultType(VectorType vectorType,
return parser.emitError(
         "expected position attribute of rank smaller than vector rank");
 
   Type resType = inferExtractOpResultType(vectorType, positionAttr);
   result.attributes = attrs;
   return failure(parser.resolveOperand(vector, type, result.operands) ||
                  parser.addTypeToList(resType, result.types));
 }
 
-static LogicalResult verify(vector::ExtractOp op) {
-  auto positionAttr = op.position().getValue();
-  if (positionAttr.size() > static_cast<unsigned>(op.getVectorType().getRank()))
-    return op.emitOpError(
+LogicalResult vector::ExtractOp::verify() {
+  auto positionAttr = position().getValue();
+  if (positionAttr.size() > static_cast<unsigned>(getVectorType().getRank()))
+    return emitOpError(
         "expected position attribute of rank smaller than vector rank");
   for (const auto &en : llvm::enumerate(positionAttr)) {
     auto attr = en.value().dyn_cast<IntegerAttr>();
     if (!attr || attr.getInt() < 0 ||
-        attr.getInt() >= op.getVectorType().getDimSize(en.index()))
-      return op.emitOpError("expected position attribute #")
+        attr.getInt() >= getVectorType().getDimSize(en.index()))
+      return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "vector dimension";
   }
   return success();
 }
 
 template <typename IntType>
for (unsigned i = 0, e = permutationMap.getNumResults(); i < e; i++) {
     AffineExpr expr = permutationMap.getResult(i);
     auto dim = expr.cast<AffineDimExpr>();
     newShape[dim.getPosition()] = newShape[dim.getPosition()] / multiplicity[i];
   }
   VectorType resultType = VectorType::get(newShape, type.getElementType());
   ExtractMapOp::build(builder, result, resultType, vector, ids);
 }
 
-static LogicalResult verify(ExtractMapOp op) {
-  if (op.getSourceVectorType().getRank() != op.getResultType().getRank())
-    return op.emitOpError(
-        "expected source and destination vectors of same rank");
+LogicalResult ExtractMapOp::verify() {
+  if (getSourceVectorType().getRank() != getResultType().getRank())
+    return emitOpError("expected source and destination vectors of same rank");
   unsigned numId = 0;
-  for (unsigned i = 0, e = op.getSourceVectorType().getRank(); i < e; ++i) {
-    if (op.getSourceVectorType().getDimSize(i) %
-            op.getResultType().getDimSize(i) !=
+  for (unsigned i = 0, e = getSourceVectorType().getRank(); i < e; ++i) {
+    if (getSourceVectorType().getDimSize(i) % getResultType().getDimSize(i) !=
         0)
-      return op.emitOpError("source vector dimensions must be a multiple of "
-                            "destination vector dimensions");
-    if (op.getSourceVectorType().getDimSize(i) !=
-        op.getResultType().getDimSize(i))
+      return emitOpError("source vector dimensions must be a multiple of "
+    if (getSourceVectorType().getDimSize(i) != getResultType().getDimSize(i))
       numId++;
   }
-  if (numId != op.ids().size())
-    return op.emitOpError("expected number of ids must match the number of "
-                          "dimensions distributed");
+  if (numId != ids().size())
+    return emitOpError("expected number of ids must match the number of "
   return success();
 }
 
 OpFoldResult ExtractMapOp::fold(ArrayRef<Attribute> operands) {
   auto insert = vector().getDefiningOp<vector::InsertMapOp>();
   if (insert == nullptr || getType() != insert.vector().getType() ||
       ids() != insert.ids())
     return {};
if (srcDim != 1 && srcDim != dstDim) {
       }
       return BroadcastableToResult::DimensionMismatch;
     }
   }
 
   return BroadcastableToResult::Success;
 }
 
-static LogicalResult verify(BroadcastOp op) {
+LogicalResult BroadcastOp::verify() {
   std::pair<int, int> mismatchingDims;
-  BroadcastableToResult res = isBroadcastableTo(
-      op.getSourceType(), op.getVectorType(), &mismatchingDims);
+  BroadcastableToResult res =
+      isBroadcastableTo(getSourceType(), getVectorType(), &mismatchingDims);
   if (res == BroadcastableToResult::Success)
     return success();
   if (res == BroadcastableToResult::SourceRankHigher)
-    return op.emitOpError("source rank higher than destination rank");
+    return emitOpError("source rank higher than destination rank");
   if (res == BroadcastableToResult::DimensionMismatch)
-    return op.emitOpError("dimension mismatch (")
+    return emitOpError("dimension mismatch (")
            << mismatchingDims.first << " vs. " << mismatchingDims.second << ")";
   if (res == BroadcastableToResult::SourceTypeNotAVector)
-    return op.emitOpError("source type is not a vector");
+    return emitOpError("source type is not a vector");
   llvm_unreachable("unexpected vector.broadcast op error");
 }
 
 OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
   if (getSourceType() == getVectorType())
     return source();
   if (!operands[0])
     return {};

 }
 
 static void print(OpAsmPrinter &p, ShuffleOp op) {
   p << " " << op.v1() << ", " << op.v2() << " " << op.mask();
   p.printOptionalAttrDict(op->getAttrs(), {ShuffleOp::getMaskAttrName()});
   p << " : " << op.v1().getType() << ", " << op.v2().getType();
 }
 
-static LogicalResult verify(ShuffleOp op) {
-  VectorType resultType = op.getVectorType();
-  VectorType v1Type = op.getV1VectorType();
-  VectorType v2Type = op.getV2VectorType();
+LogicalResult ShuffleOp::verify() {
+  VectorType resultType = getVectorType();
+  VectorType v1Type = getV1VectorType();
+  VectorType v2Type = getV2VectorType();
   // Verify ranks.
   int64_t resRank = resultType.getRank();
   int64_t v1Rank = v1Type.getRank();
   int64_t v2Rank = v2Type.getRank();
   if (resRank != v1Rank || v1Rank != v2Rank)
-    return op.emitOpError("rank mismatch");
+    return emitOpError("rank mismatch");
   // Verify all but leading dimension sizes.
   for (int64_t r = 1; r < v1Rank; ++r) {
     int64_t resDim = resultType.getDimSize(r);
     int64_t v1Dim = v1Type.getDimSize(r);
     int64_t v2Dim = v2Type.getDimSize(r);
     if (resDim != v1Dim || v1Dim != v2Dim)
-      return op.emitOpError("dimension mismatch");
+      return emitOpError("dimension mismatch");
   }
   // Verify mask length.
-  auto maskAttr = op.mask().getValue();
+  auto maskAttr = mask().getValue();
   int64_t maskLength = maskAttr.size();
   if (maskLength != resultType.getDimSize(0))
-    return op.emitOpError("mask length mismatch");
+    return emitOpError("mask length mismatch");
   // Verify all indices.
   int64_t indexSize = v1Type.getDimSize(0) + v2Type.getDimSize(0);
   for (const auto &en : llvm::enumerate(maskAttr)) {
     auto attr = en.value().dyn_cast<IntegerAttr>();
     if (!attr || attr.getInt() < 0 || attr.getInt() >= indexSize)
-      return op.emitOpError("mask index #")
-             << (en.index() + 1) << " out of range";
+      return emitOpError("mask index #") << (en.index() + 1) << " out of range";
   }
   return success();
 }
 
 static ParseResult parseShuffleOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType v1, v2;
   Attribute attr;
   VectorType v1Type, v2Type;

 }
 
 void InsertElementOp::build(OpBuilder &builder, OperationState &result,
                             Value source, Value dest, Value position) {
   result.addOperands({source, dest, position});
   result.addTypes(dest.getType());
 }
 
-static LogicalResult verify(InsertElementOp op) {
-  auto dstVectorType = op.getDestVectorType();
+LogicalResult InsertElementOp::verify() {
+  auto dstVectorType = getDestVectorType();
   if (dstVectorType.getRank() == 0) {
-    if (op.position())
-      return op.emitOpError("expected position to be empty with 0-D vector");
+    if (position())
+      return emitOpError("expected position to be empty with 0-D vector");
     return success();
   }
   if (dstVectorType.getRank() != 1)
-    return op.emitOpError("unexpected >1 vector rank");
-  if (!op.position())
-    return op.emitOpError("expected position for 1-D vector");
+    return emitOpError("unexpected >1 vector rank");
+  if (!position())
+    return emitOpError("expected position for 1-D vector");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
 void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
                      Value dest, ValueRange position) {
   SmallVector<int64_t, 4> positionConstants =
       llvm::to_vector<4>(llvm::map_range(position, [](Value pos) {
         return pos.getDefiningOp<arith::ConstantIndexOp>().value();
       }));
   build(builder, result, source, dest, positionConstants);
 }
 
-static LogicalResult verify(InsertOp op) {
-  auto positionAttr = op.position().getValue();
-  auto destVectorType = op.getDestVectorType();
+LogicalResult InsertOp::verify() {
+  auto positionAttr = position().getValue();
+  auto destVectorType = getDestVectorType();
   if (positionAttr.size() > static_cast<unsigned>(destVectorType.getRank()))
-    return op.emitOpError(
+    return emitOpError(
         "expected position attribute of rank smaller than dest vector rank");
-  auto srcVectorType = op.getSourceType().dyn_cast<VectorType>();
+  auto srcVectorType = getSourceType().dyn_cast<VectorType>();
   if (srcVectorType &&
       (static_cast<unsigned>(srcVectorType.getRank()) + positionAttr.size() !=
        static_cast<unsigned>(destVectorType.getRank())))
-    return op.emitOpError("expected position attribute rank + source rank to "
+    return emitOpError("expected position attribute rank + source rank to "
                           "match dest vector rank");
   if (!srcVectorType &&
       (positionAttr.size() != static_cast<unsigned>(destVectorType.getRank())))
-    return op.emitOpError(
+    return emitOpError(
         "expected position attribute rank to match the dest vector rank");
   for (const auto &en : llvm::enumerate(positionAttr)) {
     auto attr = en.value().dyn_cast<IntegerAttr>();
     if (!attr || attr.getInt() < 0 ||
         attr.getInt() >= destVectorType.getDimSize(en.index()))
-      return op.emitOpError("expected position attribute #")
+      return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "dest vector dimension";
   }
   return success();
 }
 
 namespace {

 // InsertMapOp
 //===----------------------------------------------------------------------===//
 
 void InsertMapOp::build(OpBuilder &builder, OperationState &result,
                         Value vector, Value dest, ValueRange ids) {
   InsertMapOp::build(builder, result, dest.getType(), vector, dest, ids);
 }
 
-static LogicalResult verify(InsertMapOp op) {
-  if (op.getSourceVectorType().getRank() != op.getResultType().getRank())
-    return op.emitOpError(
-        "expected source and destination vectors of same rank");
+LogicalResult InsertMapOp::verify() {
+  if (getSourceVectorType().getRank() != getResultType().getRank())
+    return emitOpError("expected source and destination vectors of same rank");
   unsigned numId = 0;
-  for (unsigned i = 0, e = op.getResultType().getRank(); i < e; i++) {
-    if (op.getResultType().getDimSize(i) %
-            op.getSourceVectorType().getDimSize(i) !=
+  for (unsigned i = 0, e = getResultType().getRank(); i < e; i++) {
+    if (getResultType().getDimSize(i) % getSourceVectorType().getDimSize(i) !=
         0)
-      return op.emitOpError(
+      return emitOpError(
           "destination vector size must be a multiple of source vector size");
-    if (op.getResultType().getDimSize(i) !=
-        op.getSourceVectorType().getDimSize(i))
+    if (getResultType().getDimSize(i) != getSourceVectorType().getDimSize(i))
       numId++;
   }
-  if (numId != op.ids().size())
-    return op.emitOpError("expected number of ids must match the number of "
-                          "dimensions distributed");
+  if (numId != ids().size())
+    return emitOpError("expected number of ids must match the number of "
   return success();
 }
 
 AffineMap InsertMapOp::map() { return calculateImplicitMap(*this); }
 
 //===----------------------------------------------------------------------===//
 // InsertStridedSliceOp
 //===----------------------------------------------------------------------===//

 static ArrayAttr makeI64ArrayAttr(ArrayRef<int64_t> values,
                                   MLIRContext *context) {
   auto attrs = llvm::map_range(values, [context](int64_t v) -> Attribute {
     return IntegerAttr::get(IntegerType::get(context, 64), APInt(64, v));
   });
   return ArrayAttr::get(context, llvm::to_vector<8>(attrs));
 }
 
-static LogicalResult verify(InsertStridedSliceOp op) {
-  auto sourceVectorType = op.getSourceVectorType();
-  auto destVectorType = op.getDestVectorType();
-  auto offsets = op.offsets();
-  auto strides = op.strides();
+LogicalResult InsertStridedSliceOp::verify() {
+  auto sourceVectorType = getSourceVectorType();
+  auto destVectorType = getDestVectorType();
+  auto offsets = offsetsAttr();
+  auto strides = stridesAttr();
   if (offsets.size() != static_cast<unsigned>(destVectorType.getRank()))
-    return op.emitOpError(
+    return emitOpError(
         "expected offsets of same size as destination vector rank");
   if (strides.size() != static_cast<unsigned>(sourceVectorType.getRank()))
-    return op.emitOpError(
-        "expected strides of same size as source vector rank");
+    return emitOpError("expected strides of same size as source vector rank");
   if (sourceVectorType.getRank() > destVectorType.getRank())
-    return op.emitOpError(
+    return emitOpError(
         "expected source rank to be smaller than destination rank");
 
   auto sourceShape = sourceVectorType.getShape();
   auto destShape = destVectorType.getShape();
   SmallVector<int64_t, 4> sourceShapeAsDestShape(
       destShape.size() - sourceShape.size(), 0);
   sourceShapeAsDestShape.append(sourceShape.begin(), sourceShape.end());
   auto offName = InsertStridedSliceOp::getOffsetsAttrName();
   auto stridesName = InsertStridedSliceOp::getStridesAttrName();
-  if (failed(
-          isIntegerArrayAttrConfinedToShape(op, offsets, destShape, offName)) ||
-      failed(isIntegerArrayAttrConfinedToRange(op, strides, 1, 1, stridesName,
+  if (failed(isIntegerArrayAttrConfinedToShape(*this, offsets, destShape,
+                                               offName)) ||
+      failed(isIntegerArrayAttrConfinedToRange(*this, strides, 1, 1,
+                                               stridesName,
                                                /*halfOpen=*/false)) ||
       failed(isSumOfIntegerArrayAttrConfinedToShape(
-          op, offsets,
-          makeI64ArrayAttr(sourceShapeAsDestShape, op.getContext()), destShape,
+          *this, offsets,
+          makeI64ArrayAttr(sourceShapeAsDestShape, getContext()), destShape,
           offName, "source vector shape",
           /*halfOpen=*/false, /*min=*/1)))
     return failure();
 
   return success();
 }
 
 OpFoldResult InsertStridedSliceOp::fold(ArrayRef<Attribute> operands) {
static ParseResult parseOuterProductOp(OpAsmParser &parser,
   return failure(
       parser.resolveOperand(operandsInfo[0], tLHS, result.operands) ||
       parser.resolveOperand(operandsInfo[1], tRHS, result.operands) ||
       (operandsInfo.size() > 2 &&
        parser.resolveOperand(operandsInfo[2], resType, result.operands)) ||
       parser.addTypeToList(resType, result.types));
 }
 
-static LogicalResult verify(OuterProductOp op) {
-  Type tRHS = op.getOperandTypeRHS();
-  VectorType vLHS = op.getOperandVectorTypeLHS(),
+LogicalResult OuterProductOp::verify() {
+  Type tRHS = getOperandTypeRHS();
+  VectorType vLHS = getOperandVectorTypeLHS(),
              vRHS = tRHS.dyn_cast<VectorType>(),
-             vACC = op.getOperandVectorTypeACC(), vRES = op.getVectorType();
+             vACC = getOperandVectorTypeACC(), vRES = getVectorType();
 
   if (vLHS.getRank() != 1)
-    return op.emitOpError("expected 1-d vector for operand #1");
+    return emitOpError("expected 1-d vector for operand #1");
 
   if (vRHS) {
     // Proper OUTER operation.
     if (vRHS.getRank() != 1)
-      return op.emitOpError("expected 1-d vector for operand #2");
+      return emitOpError("expected 1-d vector for operand #2");
     if (vRES.getRank() != 2)
-      return op.emitOpError("expected 2-d vector result");
+      return emitOpError("expected 2-d vector result");
     if (vLHS.getDimSize(0) != vRES.getDimSize(0))
-      return op.emitOpError("expected #1 operand dim to match result dim #1");
+      return emitOpError("expected #1 operand dim to match result dim #1");
     if (vRHS.getDimSize(0) != vRES.getDimSize(1))
-      return op.emitOpError("expected #2 operand dim to match result dim #2");
+      return emitOpError("expected #2 operand dim to match result dim #2");
   } else {
     // An AXPY operation.
     if (vRES.getRank() != 1)
-      return op.emitOpError("expected 1-d vector result");
+      return emitOpError("expected 1-d vector result");
     if (vLHS.getDimSize(0) != vRES.getDimSize(0))
-      return op.emitOpError("expected #1 operand dim to match result dim #1");
+      return emitOpError("expected #1 operand dim to match result dim #1");
   }
 
   if (vACC && vACC != vRES)
-    return op.emitOpError("expected operand #3 of same type as result type");
+    return emitOpError("expected operand #3 of same type as result type");
 
   // Verify supported combining kind.
-  if (!isSupportedCombiningKind(op.kind(), vRES.getElementType()))
-    return op.emitOpError("unsupported outerproduct type");
+  if (!isSupportedCombiningKind(kind(), vRES.getElementType()))
+    return emitOpError("unsupported outerproduct type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReshapeOp op) {
+LogicalResult ReshapeOp::verify() {
   // Verify that rank(numInputs/outputs) + numFixedVec dim matches vec rank.
-  auto inputVectorType = op.getInputVectorType();
-  auto outputVectorType = op.getOutputVectorType();
-  int64_t inputShapeRank = op.getNumInputShapeSizes();
-  int64_t outputShapeRank = op.getNumOutputShapeSizes();
+  auto inputVectorType = getInputVectorType();
+  auto outputVectorType = getOutputVectorType();
+  int64_t inputShapeRank = getNumInputShapeSizes();
+  int64_t outputShapeRank = getNumOutputShapeSizes();
   SmallVector<int64_t, 4> fixedVectorSizes;
-  op.getFixedVectorSizes(fixedVectorSizes);
+  getFixedVectorSizes(fixedVectorSizes);
   int64_t numFixedVectorSizes = fixedVectorSizes.size();
 
   if (inputVectorType.getRank() != inputShapeRank + numFixedVectorSizes)
-    return op.emitError("invalid input shape for vector type ")
+    return emitError("invalid input shape for vector type ")
            << inputVectorType;
 
   if (outputVectorType.getRank() != outputShapeRank + numFixedVectorSizes)
-    return op.emitError("invalid output shape for vector type ")
+    return emitError("invalid output shape for vector type ")
            << outputVectorType;
 
   // Verify that the 'fixedVectorSizes' match an input/output vector shape
   // suffix.
   unsigned inputVectorRank = inputVectorType.getRank();
   for (unsigned i = 0; i < numFixedVectorSizes; ++i) {
     unsigned index = inputVectorRank - numFixedVectorSizes - i;
     if (fixedVectorSizes[i] != inputVectorType.getShape()[index])
-      return op.emitError("fixed vector size must match input vector for dim ")
+      return emitError("fixed vector size must match input vector for dim ")
              << i;
   }
 
   unsigned outputVectorRank = outputVectorType.getRank();
   for (unsigned i = 0; i < numFixedVectorSizes; ++i) {
     unsigned index = outputVectorRank - numFixedVectorSizes - i;
     if (fixedVectorSizes[i] != outputVectorType.getShape()[index])
-      return op.emitError("fixed vector size must match output vector for dim ")
+      return emitError("fixed vector size must match output vector for dim ")
              << i;
   }
 
   // If all shape operands are produced by constant ops, verify that product
   // of dimensions for input/output shape match.
   auto isDefByConstant = [](Value operand) {
     return isa_and_nonnull<arith::ConstantIndexOp>(operand.getDefiningOp());
   };
-  if (llvm::all_of(op.input_shape(), isDefByConstant) &&
-      llvm::all_of(op.output_shape(), isDefByConstant)) {
+  if (llvm::all_of(input_shape(), isDefByConstant) &&
+      llvm::all_of(output_shape(), isDefByConstant)) {
     int64_t numInputElements = 1;
-    for (auto operand : op.input_shape())
+    for (auto operand : input_shape())
       numInputElements *=
           cast<arith::ConstantIndexOp>(operand.getDefiningOp()).value();
     int64_t numOutputElements = 1;
-    for (auto operand : op.output_shape())
+    for (auto operand : output_shape())
       numOutputElements *=
           cast<arith::ConstantIndexOp>(operand.getDefiningOp()).value();
     if (numInputElements != numOutputElements)
-      return op.emitError("product of input and output shape sizes must match");
+      return emitError("product of input and output shape sizes must match");
   }
   return success();
 }
 
 void ReshapeOp::getFixedVectorSizes(SmallVectorImpl<int64_t> &results) {
   populateFromInt64AttrArray(fixed_vector_sizes(), results);
 }
 
void ExtractStridedSliceOp::build(OpBuilder &builder, OperationState &result,
   result.addTypes(
       inferStridedSliceOpResultType(source.getType().cast<VectorType>(),
                                     offsetsAttr, sizesAttr, stridesAttr));
   result.addAttribute(getOffsetsAttrName(), offsetsAttr);
   result.addAttribute(getSizesAttrName(), sizesAttr);
   result.addAttribute(getStridesAttrName(), stridesAttr);
 }
 
-static LogicalResult verify(ExtractStridedSliceOp op) {
-  auto type = op.getVectorType();
-  auto offsets = op.offsets();
-  auto sizes = op.sizes();
-  auto strides = op.strides();
-  if (offsets.size() != sizes.size() || offsets.size() != strides.size()) {
-    op.emitOpError(
-        "expected offsets, sizes and strides attributes of same size");
-    return failure();
-  }
+LogicalResult ExtractStridedSliceOp::verify() {
+  auto type = getVectorType();
+  auto offsets = offsetsAttr();
+  auto sizes = sizesAttr();
+  auto strides = stridesAttr();
+  if (offsets.size() != sizes.size() || offsets.size() != strides.size())
+    return emitOpError("expected offsets, sizes and strides attributes of same size");
 
   auto shape = type.getShape();
-  auto offName = ExtractStridedSliceOp::getOffsetsAttrName();
-  auto sizesName = ExtractStridedSliceOp::getSizesAttrName();
-  auto stridesName = ExtractStridedSliceOp::getStridesAttrName();
-  if (failed(isIntegerArrayAttrSmallerThanShape(op, offsets, shape, offName)) ||
-      failed(isIntegerArrayAttrSmallerThanShape(op, sizes, shape, sizesName)) ||
-      failed(isIntegerArrayAttrSmallerThanShape(op, strides, shape,
+  auto offName = getOffsetsAttrName();
+  auto sizesName = getSizesAttrName();
+  auto stridesName = getStridesAttrName();
+  if (failed(isIntegerArrayAttrSmallerThanShape(*this, offsets, shape, offName)) ||
+      failed(isIntegerArrayAttrSmallerThanShape(*this, sizes, shape, sizesName)) ||
+      failed(isIntegerArrayAttrSmallerThanShape(*this, strides, shape,
                                                 stridesName)) ||
-      failed(isIntegerArrayAttrConfinedToShape(op, offsets, shape, offName)) ||
-      failed(isIntegerArrayAttrConfinedToShape(op, sizes, shape, sizesName,
+      failed(isIntegerArrayAttrConfinedToShape(*this, offsets, shape, offName)) ||
+      failed(isIntegerArrayAttrConfinedToShape(*this, sizes, shape, sizesName,
                                                /*halfOpen=*/false,
                                                /*min=*/1)) ||
-      failed(isIntegerArrayAttrConfinedToRange(op, strides, 1, 1, stridesName,
+      failed(isIntegerArrayAttrConfinedToRange(*this, strides, 1, 1, stridesName,
                                                /*halfOpen=*/false)) ||
-      failed(isSumOfIntegerArrayAttrConfinedToShape(op, offsets, sizes, shape,
+      failed(isSumOfIntegerArrayAttrConfinedToShape(*this, offsets, sizes, shape,
                                                     offName, sizesName,
                                                     /*halfOpen=*/false)))
     return failure();
 
-  auto resultType = inferStridedSliceOpResultType(
-      op.getVectorType(), op.offsets(), op.sizes(), op.strides());
-  if (op.getResult().getType() != resultType) {
-    op.emitOpError("expected result type to be ") << resultType;
-    return failure();
-  }
+  auto resultType =
+      inferStridedSliceOpResultType(getVectorType(), offsets, sizes, strides);
+  if (getResult().getType() != resultType)
+    return emitOpError("expected result type to be ") << resultType;
 
   return success();
 }
 
 // When the source of ExtractStrided comes from a chain of InsertStrided ops try
 // to use the source of the InsertStrided ops if we can detect that the
 // extracted vector is a subset of one of the vector inserted.
 static LogicalResult
static ParseResult parseTransferReadOp(OpAsmParser &parser,
   }
   result.addAttribute(
       TransferReadOp::getOperandSegmentSizeAttr(),
       builder.getI32VectorAttr({1, static_cast<int32_t>(indexInfo.size()), 1,
                                 static_cast<int32_t>(hasMask.succeeded())}));
   return parser.addTypeToList(vectorType, result.types);
 }
 
-static LogicalResult verify(TransferReadOp op) {
+LogicalResult TransferReadOp::verify() {
   // Consistency of elemental types in source and vector.
-  ShapedType shapedType = op.getShapedType();
-  VectorType vectorType = op.getVectorType();
-  VectorType maskType = op.getMaskType();
-  auto paddingType = op.padding().getType();
-  auto permutationMap = op.permutation_map();
+  ShapedType shapedType = getShapedType();
+  VectorType vectorType = getVectorType();
+  VectorType maskType = getMaskType();
+  auto paddingType = padding().getType();
+  auto permutationMap = permutation_map();
   auto sourceElementType = shapedType.getElementType();
 
-  if (static_cast<int64_t>(op.indices().size()) != shapedType.getRank())
-    return op.emitOpError("requires ") << shapedType.getRank() << " indices";
+  if (static_cast<int64_t>(indices().size()) != shapedType.getRank())
+    return emitOpError("requires ") << shapedType.getRank() << " indices";
 
-  if (failed(
-          verifyTransferOp(cast<VectorTransferOpInterface>(op.getOperation()),
+  if (failed(verifyTransferOp(cast<VectorTransferOpInterface>(getOperation()),
                               shapedType, vectorType, maskType, permutationMap,
-                           op.in_bounds() ? *op.in_bounds() : ArrayAttr())))
+                              in_bounds() ? *in_bounds() : ArrayAttr())))
     return failure();
 
   if (auto sourceVectorElementType = sourceElementType.dyn_cast<VectorType>()) {
     // Source has vector element type.
     // Check that 'sourceVectorElementType' and 'paddingType' types match.
     if (sourceVectorElementType != paddingType)
-      return op.emitOpError(
+      return emitOpError(
           "requires source element type and padding type to match.");
 
   } else {
     // Check that 'paddingType' is valid to store in a vector type.
     if (!VectorType::isValidElementType(paddingType))
-      return op.emitOpError("requires valid padding vector elemental type");
+      return emitOpError("requires valid padding vector elemental type");
 
     // Check that padding type and vector element types match.
     if (paddingType != sourceElementType)
-      return op.emitOpError(
+      return emitOpError(
           "requires formal padding and source of the same elemental type");
   }
 
   return verifyPermutationMap(permutationMap,
-                              [&op](Twine t) { return op.emitOpError(t); });
+                              [&](Twine t) { return emitOpError(t); });
 }
 
 /// This is a common class used for patterns of the form
 /// ```
 ///    someop(memrefcast) -> someop
 /// ```
 /// It folds the source of the memref.cast into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {

 static void print(OpAsmPrinter &p, TransferWriteOp op) {
   p << " " << op.vector() << ", " << op.source() << "[" << op.indices() << "]";
   if (op.mask())
     p << ", " << op.mask();
   printTransferAttrs(p, cast<VectorTransferOpInterface>(op.getOperation()));
   p << " : " << op.getVectorType() << ", " << op.getShapedType();
 }
 
-static LogicalResult verify(TransferWriteOp op) {
+LogicalResult TransferWriteOp::verify() {
   // Consistency of elemental types in shape and vector.
-  ShapedType shapedType = op.getShapedType();
-  VectorType vectorType = op.getVectorType();
-  VectorType maskType = op.getMaskType();
-  auto permutationMap = op.permutation_map();
+  ShapedType shapedType = getShapedType();
+  VectorType vectorType = getVectorType();
+  VectorType maskType = getMaskType();
+  auto permutationMap = permutation_map();
 
-  if (llvm::size(op.indices()) != shapedType.getRank())
-    return op.emitOpError("requires ") << shapedType.getRank() << " indices";
+  if (llvm::size(indices()) != shapedType.getRank())
+    return emitOpError("requires ") << shapedType.getRank() << " indices";
 
   // We do not allow broadcast dimensions on TransferWriteOps for the moment,
   // as the semantics is unclear. This can be revisited later if necessary.
-  if (op.hasBroadcastDim())
-    return op.emitOpError("should not have broadcast dimensions");
+  if (hasBroadcastDim())
+    return emitOpError("should not have broadcast dimensions");
 
-  if (failed(
-          verifyTransferOp(cast<VectorTransferOpInterface>(op.getOperation()),
+  if (failed(verifyTransferOp(cast<VectorTransferOpInterface>(getOperation()),
                               shapedType, vectorType, maskType, permutationMap,
-                           op.in_bounds() ? *op.in_bounds() : ArrayAttr())))
+                              in_bounds() ? *in_bounds() : ArrayAttr())))
     return failure();
 
   return verifyPermutationMap(permutationMap,
-                              [&op](Twine t) { return op.emitOpError(t); });
+                              [&](Twine t) { return emitOpError(t); });
 }
 
 /// Fold:
 /// ```
 ///    %t1 = ...
 ///    %v = vector.transfer_read %t0[%c0...], {in_bounds = [true...]} :
 ///      tensor<static_sizesxf32>, vector<static_sizesxf32>
 ///    %t2 = vector.transfer_write %v, %t1[%c0...] {in_bounds = [true...]} :

 
 static LogicalResult verifyLoadStoreMemRefLayout(Operation *op,
                                                  MemRefType memRefTy) {
   if (!isLastMemrefDimUnitStride(memRefTy))
     return op->emitOpError("most minor memref dim must have unit stride");
   return success();
 }
 
-static LogicalResult verify(vector::LoadOp op) {
-  VectorType resVecTy = op.getVectorType();
-  MemRefType memRefTy = op.getMemRefType();
+LogicalResult vector::LoadOp::verify() {
+  VectorType resVecTy = getVectorType();
+  MemRefType memRefTy = getMemRefType();
 
-  if (failed(verifyLoadStoreMemRefLayout(op, memRefTy)))
+  if (failed(verifyLoadStoreMemRefLayout(*this, memRefTy)))
     return failure();
 
   // Checks for vector memrefs.
   Type memElemTy = memRefTy.getElementType();
   if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
     if (memVecTy != resVecTy)
-      return op.emitOpError("base memref and result vector types should match");
+      return emitOpError("base memref and result vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (resVecTy.getElementType() != memElemTy)
-    return op.emitOpError("base and result element types should match");
-  if (llvm::size(op.indices()) != memRefTy.getRank())
-    return op.emitOpError("requires ") << memRefTy.getRank() << " indices";
+    return emitOpError("base and result element types should match");
+  if (llvm::size(indices()) != memRefTy.getRank())
+    return emitOpError("requires ") << memRefTy.getRank() << " indices";
   return success();
 }
 
 OpFoldResult LoadOp::fold(ArrayRef<Attribute>) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(vector::StoreOp op) {
-  VectorType valueVecTy = op.getVectorType();
-  MemRefType memRefTy = op.getMemRefType();
+LogicalResult vector::StoreOp::verify() {
+  VectorType valueVecTy = getVectorType();
+  MemRefType memRefTy = getMemRefType();
 
-  if (failed(verifyLoadStoreMemRefLayout(op, memRefTy)))
+  if (failed(verifyLoadStoreMemRefLayout(*this, memRefTy)))
     return failure();
 
   // Checks for vector memrefs.
   Type memElemTy = memRefTy.getElementType();
   if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
     if (memVecTy != valueVecTy)
-      return op.emitOpError(
+      return emitOpError(
           "base memref and valueToStore vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (valueVecTy.getElementType() != memElemTy)
-    return op.emitOpError("base and valueToStore element type should match");
-  if (llvm::size(op.indices()) != memRefTy.getRank())
-    return op.emitOpError("requires ") << memRefTy.getRank() << " indices";
+    return emitOpError("base and valueToStore element type should match");
+  if (llvm::size(indices()) != memRefTy.getRank())
+    return emitOpError("requires ") << memRefTy.getRank() << " indices";
   return success();
 }
 
 LogicalResult StoreOp::fold(ArrayRef<Attribute> operands,
                             SmallVectorImpl<OpFoldResult> &results) {
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // MaskedLoadOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(MaskedLoadOp op) {
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType passVType = op.getPassThruVectorType();
-  VectorType resVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult MaskedLoadOp::verify() {
+  VectorType maskVType = getMaskVectorType();
+  VectorType passVType = getPassThruVectorType();
+  VectorType resVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and result element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and result element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected result dim to match mask dim");
+    return emitOpError("expected result dim to match mask dim");
   if (resVType != passVType)
-    return op.emitOpError("expected pass_thru of same type as result type");
+    return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class MaskedLoadFolder final : public OpRewritePattern<MaskedLoadOp> {
 public:
   using OpRewritePattern<MaskedLoadOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(MaskedLoadOp load,
if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
 // MaskedStoreOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(MaskedStoreOp op) {
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType valueVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult MaskedStoreOp::verify() {
+  VectorType maskVType = getMaskVectorType();
+  VectorType valueVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and valueToStore element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and valueToStore element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected valueToStore dim to match mask dim");
+    return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class MaskedStoreFolder final : public OpRewritePattern<MaskedStoreOp> {
 public:
   using OpRewritePattern<MaskedStoreOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(MaskedStoreOp store,
LogicalResult MaskedStoreOp::fold(ArrayRef<Attribute> operands,
                                   SmallVectorImpl<OpFoldResult> &results) {
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // GatherOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(GatherOp op) {
-  VectorType indVType = op.getIndexVectorType();
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType resVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult GatherOp::verify() {
+  VectorType indVType = getIndexVectorType();
+  VectorType maskVType = getMaskVectorType();
+  VectorType resVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and result element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and result element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != indVType.getDimSize(0))
-    return op.emitOpError("expected result dim to match indices dim");
+    return emitOpError("expected result dim to match indices dim");
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected result dim to match mask dim");
-  if (resVType != op.getPassThruVectorType())
-    return op.emitOpError("expected pass_thru of same type as result type");
+    return emitOpError("expected result dim to match mask dim");
+  if (resVType != getPassThruVectorType())
+    return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class GatherFolder final : public OpRewritePattern<GatherOp> {
 public:
   using OpRewritePattern<GatherOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(GatherOp gather,
void GatherOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.add<GatherFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ScatterOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ScatterOp op) {
-  VectorType indVType = op.getIndexVectorType();
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType valueVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult ScatterOp::verify() {
+  VectorType indVType = getIndexVectorType();
+  VectorType maskVType = getMaskVectorType();
+  VectorType valueVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and valueToStore element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and valueToStore element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != indVType.getDimSize(0))
-    return op.emitOpError("expected valueToStore dim to match indices dim");
+    return emitOpError("expected valueToStore dim to match indices dim");
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected valueToStore dim to match mask dim");
+    return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class ScatterFolder final : public OpRewritePattern<ScatterOp> {
 public:
   using OpRewritePattern<ScatterOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(ScatterOp scatter,
void ScatterOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results.add<ScatterFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ExpandLoadOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ExpandLoadOp op) {
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType passVType = op.getPassThruVectorType();
-  VectorType resVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult ExpandLoadOp::verify() {
+  VectorType maskVType = getMaskVectorType();
+  VectorType passVType = getPassThruVectorType();
+  VectorType resVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and result element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and result element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected result dim to match mask dim");
+    return emitOpError("expected result dim to match mask dim");
   if (resVType != passVType)
-    return op.emitOpError("expected pass_thru of same type as result type");
+    return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class ExpandLoadFolder final : public OpRewritePattern<ExpandLoadOp> {
 public:
   using OpRewritePattern<ExpandLoadOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(ExpandLoadOp expand,
void ExpandLoadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<ExpandLoadFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // CompressStoreOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(CompressStoreOp op) {
-  VectorType maskVType = op.getMaskVectorType();
-  VectorType valueVType = op.getVectorType();
-  MemRefType memType = op.getMemRefType();
+LogicalResult CompressStoreOp::verify() {
+  VectorType maskVType = getMaskVectorType();
+  VectorType valueVType = getVectorType();
+  MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
-    return op.emitOpError("base and valueToStore element type should match");
-  if (llvm::size(op.indices()) != memType.getRank())
-    return op.emitOpError("requires ") << memType.getRank() << " indices";
+    return emitOpError("base and valueToStore element type should match");
+  if (llvm::size(indices()) != memType.getRank())
+    return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
-    return op.emitOpError("expected valueToStore dim to match mask dim");
+    return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class CompressStoreFolder final : public OpRewritePattern<CompressStoreOp> {
 public:
   using OpRewritePattern<CompressStoreOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(CompressStoreOp compress,
if (!isValidShapeCast(sourceShape, resultShape))
       return op->emitOpError("invalid shape cast");
   } else if (sourceRank > resultRank) {
     if (!isValidShapeCast(resultShape, sourceShape))
       return op->emitOpError("invalid shape cast");
   }
   return success();
 }
 
-static LogicalResult verify(ShapeCastOp op) {
-  auto sourceVectorType = op.source().getType().dyn_cast_or_null<VectorType>();
-  auto resultVectorType = op.result().getType().dyn_cast_or_null<VectorType>();
+LogicalResult ShapeCastOp::verify() {
+  auto sourceVectorType = source().getType().dyn_cast_or_null<VectorType>();
+  auto resultVectorType = result().getType().dyn_cast_or_null<VectorType>();
 
   // Check if source/result are of vector type.
   if (sourceVectorType && resultVectorType)
-    return verifyVectorShapeCast(op, sourceVectorType, resultVectorType);
+    return verifyVectorShapeCast(*this, sourceVectorType, resultVectorType);
 
   return success();
 }
 
 OpFoldResult ShapeCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop shape cast.
   if (source().getType() == result().getType())
     return source();
void ShapeCastOp::getCanonicalizationPatterns(RewritePatternSet &results,
   // Pattern to rewrite a ShapeCastOp(ConstantOp) -> ConstantOp.
   results.add<ShapeCastConstantFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // VectorBitCastOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(BitCastOp op) {
-  auto sourceVectorType = op.getSourceVectorType();
-  auto resultVectorType = op.getResultVectorType();
+LogicalResult BitCastOp::verify() {
+  auto sourceVectorType = getSourceVectorType();
+  auto resultVectorType = getResultVectorType();
 
   for (int64_t i = 0, e = sourceVectorType.getRank() - 1; i < e; i++) {
     if (sourceVectorType.getDimSize(i) != resultVectorType.getDimSize(i))
-      return op.emitOpError("dimension size mismatch at: ") << i;
+      return emitOpError("dimension size mismatch at: ") << i;
   }
 
-  DataLayout dataLayout = DataLayout::closest(op);
+  DataLayout dataLayout = DataLayout::closest(*this);
   auto sourceElementBits =
       dataLayout.getTypeSizeInBits(sourceVectorType.getElementType());
   auto resultElementBits =
       dataLayout.getTypeSizeInBits(resultVectorType.getElementType());
 
   if (sourceVectorType.getRank() == 0) {
     if (sourceElementBits != resultElementBits)
-      return op.emitOpError("source/result bitwidth of the 0-D vector element "
+      return emitOpError("source/result bitwidth of the 0-D vector element "
                             "types must be equal");
   } else if (sourceElementBits * sourceVectorType.getShape().back() !=
              resultElementBits * resultVectorType.getShape().back()) {
-    return op.emitOpError(
+    return emitOpError(
         "source/result bitwidth of the minor 1-D vectors must be equal");
   }
 
   return success();
 }
 
 OpFoldResult BitCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop cast.
void TypeCastOp::build(OpBuilder &builder, OperationState &result,
   MemRefType memRefType = source.getType().cast<MemRefType>();
   VectorType vectorType =
       VectorType::get(extractShape(memRefType),
                       getElementTypeOrSelf(getElementTypeOrSelf(memRefType)));
   result.addTypes(MemRefType::get({}, vectorType, MemRefLayoutAttrInterface(),
                                   memRefType.getMemorySpace()));
 }
 
-static LogicalResult verify(TypeCastOp op) {
-  MemRefType canonicalType = canonicalizeStridedLayout(op.getMemRefType());
+LogicalResult TypeCastOp::verify() {
+  MemRefType canonicalType = canonicalizeStridedLayout(getMemRefType());
   if (!canonicalType.getLayout().isIdentity())
-    return op.emitOpError(
-        "expects operand to be a memref with identity layout");
-  if (!op.getResultMemRefType().getLayout().isIdentity())
-    return op.emitOpError("expects result to be a memref with identity layout");
-  if (op.getResultMemRefType().getMemorySpace() !=
-      op.getMemRefType().getMemorySpace())
-    return op.emitOpError("expects result in same memory space");
+    return emitOpError("expects operand to be a memref with identity layout");
+  if (!getResultMemRefType().getLayout().isIdentity())
+    return emitOpError("expects result to be a memref with identity layout");
+  if (getResultMemRefType().getMemorySpace() !=
+      getMemRefType().getMemorySpace())
+    return emitOpError("expects result in same memory space");
 
-  auto sourceType = op.getMemRefType();
-  auto resultType = op.getResultMemRefType();
+  auto sourceType = getMemRefType();
+  auto resultType = getResultMemRefType();
   if (getElementTypeOrSelf(getElementTypeOrSelf(sourceType)) !=
       getElementTypeOrSelf(getElementTypeOrSelf(resultType)))
-    return op.emitOpError(
+    return emitOpError(
                "expects result and operand with same underlying scalar type: ")
            << resultType;
   if (extractShape(sourceType) != extractShape(resultType))
-    return op.emitOpError(
+    return emitOpError(
                "expects concatenated result and operand shapes to be equal: ")
            << resultType;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
   for (int64_t i = 0, e = transp.size(); i < e; i++) {
     if (transp[i] != i)
       return {};
   }
 
   return vector();
 }
 
-static LogicalResult verify(vector::TransposeOp op) {
-  VectorType vectorType = op.getVectorType();
-  VectorType resultType = op.getResultType();
+LogicalResult vector::TransposeOp::verify() {
+  VectorType vectorType = getVectorType();
+  VectorType resultType = getResultType();
   int64_t rank = resultType.getRank();
   if (vectorType.getRank() != rank)
-    return op.emitOpError("vector result rank mismatch: ") << rank;
+    return emitOpError("vector result rank mismatch: ") << rank;
   // Verify transposition array.
-  auto transpAttr = op.transp().getValue();
+  auto transpAttr = transp().getValue();
   int64_t size = transpAttr.size();
   if (rank != size)
-    return op.emitOpError("transposition length mismatch: ") << size;
+    return emitOpError("transposition length mismatch: ") << size;
   SmallVector<bool, 8> seen(rank, false);
   for (const auto &ta : llvm::enumerate(transpAttr)) {
     int64_t i = ta.value().cast<IntegerAttr>().getInt();
     if (i < 0 || i >= rank)
-      return op.emitOpError("transposition index out of range: ") << i;
+      return emitOpError("transposition index out of range: ") << i;
     if (seen[i])
-      return op.emitOpError("duplicate position index: ") << i;
+      return emitOpError("duplicate position index: ") << i;
     seen[i] = true;
     if (resultType.getDimSize(ta.index()) != vectorType.getDimSize(i))
-      return op.emitOpError("dimension size mismatch at: ") << i;
+      return emitOpError("dimension size mismatch at: ") << i;
   }
   return success();
 }
 
 namespace {
 
 // Rewrites two back-to-back TransposeOp operations into a single TransposeOp.
 class TransposeFolder final : public OpRewritePattern<vector::TransposeOp> {

 void vector::TransposeOp::getTransp(SmallVectorImpl<int64_t> &results) {
   populateFromInt64AttrArray(transp(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantMaskOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ConstantMaskOp &op) {
-  auto resultType = op.getResult().getType().cast<VectorType>();
+LogicalResult ConstantMaskOp::verify() {
+  auto resultType = getResult().getType().cast<VectorType>();
   // Check the corner case of 0-D vectors first.
   if (resultType.getRank() == 0) {
-    if (op.mask_dim_sizes().size() != 1)
-      return op->emitError("array attr must have length 1 for 0-D vectors");
-    auto dim = op.mask_dim_sizes()[0].cast<IntegerAttr>().getInt();
+    if (mask_dim_sizes().size() != 1)
+      return emitError("array attr must have length 1 for 0-D vectors");
+    auto dim = mask_dim_sizes()[0].cast<IntegerAttr>().getInt();
     if (dim != 0 && dim != 1)
-      return op->emitError(
-          "mask dim size must be either 0 or 1 for 0-D vectors");
+      return emitError("mask dim size must be either 0 or 1 for 0-D vectors");
     return success();
   }
 
   // Verify that array attr size matches the rank of the vector result.
-  if (static_cast<int64_t>(op.mask_dim_sizes().size()) != resultType.getRank())
-    return op.emitOpError(
+  if (static_cast<int64_t>(mask_dim_sizes().size()) != resultType.getRank())
+    return emitOpError(
         "must specify array attr of size equal vector result rank");
   // Verify that each array attr element is in bounds of corresponding vector
   // result dimension size.
   auto resultShape = resultType.getShape();
   SmallVector<int64_t, 4> maskDimSizes;
-  for (const auto &it : llvm::enumerate(op.mask_dim_sizes())) {
+  for (const auto &it : llvm::enumerate(mask_dim_sizes())) {
     int64_t attrValue = it.value().cast<IntegerAttr>().getInt();
     if (attrValue < 0 || attrValue > resultShape[it.index()])
-      return op.emitOpError(
+      return emitOpError(
           "array attr of size out of bounds of vector result dimension size");
     maskDimSizes.push_back(attrValue);
   }
   // Verify that if one mask dim size is zero, they all should be zero (because
   // the mask region is a conjunction of each mask dimension interval).
   bool anyZeros = llvm::is_contained(maskDimSizes, 0);
   bool allZeros = llvm::all_of(maskDimSizes, [](int64_t s) { return s == 0; });
   if (anyZeros && !allZeros)
-    return op.emitOpError("expected all mask dim sizes to be zeros, "
-                          "as a result of conjunction with zero mask dim");
+    return emitOpError("expected all mask dim sizes to be zeros, "
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CreateMaskOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(CreateMaskOp op) {
-  auto vectorType = op.getResult().getType().cast<VectorType>();
+LogicalResult CreateMaskOp::verify() {
+  auto vectorType = getResult().getType().cast<VectorType>();
   // Verify that an operand was specified for each result vector each dimension.
   if (vectorType.getRank() == 0) {
-    if (op->getNumOperands() != 1)
-      return op.emitOpError(
+    if (getNumOperands() != 1)
+      return emitOpError(
           "must specify exactly one operand for 0-D create_mask");
-  } else if (op.getNumOperands() !=
-             op.getResult().getType().cast<VectorType>().getRank()) {
-    return op.emitOpError(
+  } else if (getNumOperands() !=
+             getResult().getType().cast<VectorType>().getRank()) {
+    return emitOpError(
         "must specify an operand for each result vector dimension");
   }
   return success();
 }
 
 namespace {
 
 // Pattern to rewrite a CreateMaskOp with a ConstantMaskOp.
void CreateMaskOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<CreateMaskFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ScanOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ScanOp op) {
-  VectorType srcType = op.getSourceType();
-  VectorType initialType = op.getInitialValueType();
+LogicalResult ScanOp::verify() {
+  VectorType srcType = getSourceType();
+  VectorType initialType = getInitialValueType();
   // Check reduction dimension < rank.
   int64_t srcRank = srcType.getRank();
-  int64_t reductionDim = op.reduction_dim();
+  int64_t reductionDim = reduction_dim();
   if (reductionDim >= srcRank)
-    return op.emitOpError("reduction dimension ")
+    return emitOpError("reduction dimension ")
            << reductionDim << " has to be less than " << srcRank;
 
   // Check that rank(initial_value) = rank(src) - 1.
   int64_t initialValueRank = initialType.getRank();
   if (initialValueRank != srcRank - 1)
-    return op.emitOpError("initial value rank ")
+    return emitOpError("initial value rank ")
            << initialValueRank << " has to be equal to " << srcRank - 1;
 
   // Check shapes of initial value and src.
   ArrayRef<int64_t> srcShape = srcType.getShape();
   ArrayRef<int64_t> initialValueShapes = initialType.getShape();
   SmallVector<int64_t> expectedShape;
   for (int i = 0; i < srcRank; i++) {
     if (i != reductionDim)
       expectedShape.push_back(srcShape[i]);
   }
   if (llvm::any_of(llvm::zip(initialValueShapes, expectedShape),
                    [](std::tuple<int64_t, int64_t> s) {
                      return std::get<0>(s) != std::get<1>(s);
                    })) {
-    return op.emitOpError("incompatible input/initial value shapes");
+    return emitOpError("incompatible input/initial value shapes");
   }
 
   return success();
 }
 
 void mlir::vector::populateVectorToVectorCanonicalizationPatterns(
     RewritePatternSet &patterns) {
   patterns
       .add<CreateMaskFolder, MaskedLoadFolder, MaskedStoreFolder, GatherFolder,
            ScatterFolder, ExpandLoadFolder, CompressStoreFolder,
            StridedSliceConstantMaskFolder, TransposeFolder>(
           patterns.getContext());
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Vector/IR/VectorOps.cpp.inc"