[mlir][NFC] Update GPU/SCF operations to use `hasVerifier` instead of `verifier`

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

Depends on D118826

[mehdi_amini]

I think you should just directly push all these mechanical changes, this is really in line with the usual LLVM guidelines I believe.

mlir/include/mlir/Dialect/GPU/GPUOps.td

let description = [{
     Example:
 
     ```mlir
     %sgId = gpu.subgroup_id : index
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
-  let verifier = [{ return success(); }];
 }
 
 def GPU_NumSubgroupsOp : GPU_Op<"num_subgroups", [NoSideEffect]>,
     Arguments<(ins)>, Results<(outs Index:$result)> {
   let description = [{
     Returns the number of subgroups within a workgroup.
 
     Example:
 
     ```mlir
     %numSg = gpu.num_subgroups : index
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
-  let verifier = [{ return success(); }];
 }
 
 def GPU_SubgroupSizeOp : GPU_Op<"subgroup_size", [NoSideEffect]>,
     Arguments<(ins)>, Results<(outs Index:$result)> {
   let description = [{
     Returns the number of threads within a subgroup.
 
     Example:
 
     ```mlir
     %sgSz = gpu.subgroup_size : index
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
-  let verifier = [{ return success(); }];
 }
 
 def GPU_GPUFuncOp : GPU_Op<"func", [
     HasParent<"GPUModuleOp">, AutomaticAllocationScope, FunctionOpInterface,
     IsolatedFromAbove, Symbol
   ]> {
   let summary = "Function executable on a GPU";
 
let extraClassDeclaration = [{
 
     /// Hook for FunctionOpInterface verifier.
     LogicalResult verifyType();
 
     /// Verifies the body of the function.
     LogicalResult verifyBody();
   }];
 
-  // let verifier = [{ return ::verifFuncOpy(*this); }];
   let printer = [{ printGPUFuncOp(p, *this); }];
   let parser = [{ return parseGPUFuncOp(parser, result); }];
 }
 
 def GPU_LaunchFuncOp : GPU_Op<"launch_func",
                               [GPU_AsyncOpInterface, AttrSizedOperandSegments]>,
     Arguments<(ins Variadic<GPU_AsyncToken>:$asyncDependencies,
                SymbolRefAttr:$kernel,
let extraClassDeclaration = [{
     // present since it is run before the verifier of this op.
     friend LogicalResult GPUDialect::verifyOperationAttribute(Operation *,
                                                               NamedAttribute);
 
     /// The name of the symbol reference attribute specifying the kernel to launch.
     static StringRef getKernelAttrName() { return "kernel"; }
   }];
 
-  let verifier = [{ return ::verify(*this); }];
   let assemblyFormat = [{
       custom<AsyncDependencies>(type($asyncToken), $asyncDependencies)
       $kernel
       `blocks` `in` ` ` `(`$gridSizeX`,` $gridSizeY`,` $gridSizeZ`)`
       `threads` `in` ` ` `(`$blockSizeX`,` $blockSizeY`,` $blockSizeZ`)`
       (`dynamic_shared_memory_size` $dynamicSharedMemorySize^)?
       custom<LaunchFuncOperands>($operands, type($operands)) attr-dict
   }];
+  let hasVerifier = 1;
 }
 
 def GPU_LaunchOp : GPU_Op<"launch">,
     Arguments<(ins Index:$gridSizeX, Index:$gridSizeY, Index:$gridSizeZ,
                Index:$blockSizeX, Index:$blockSizeY, Index:$blockSizeZ,
                Optional<I32>:$dynamicSharedMemorySize)>,
     Results<(outs)> {
   let summary = "GPU kernel launch operation";
let extraClassDeclaration = [{
 
     /// The number of region attributes containing the launch configuration,
     /// placed in the leading positions of the argument list.
     static constexpr unsigned kNumConfigRegionAttributes = 12;
   }];
 
   let parser = [{ return parseLaunchOp(parser, result); }];
   let printer = [{ printLaunchOp(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def GPU_PrintfOp : GPU_Op<"printf", [MemoryEffects<[MemWrite]>]>,
   Arguments<(ins StrAttr:$format,
                 Variadic<AnyTypeOf<[AnyInteger, Index, AnyFloat]>>:$args)> {
   let summary = "Device-side printf, as in CUDA or OpenCL, for debugging";
   let description = [{
     `gpu.printf` takes a literal format string `format` and an arbitrary number of
let description = [{
     A terminator operation for regions that appear in the body of  `gpu.func`
     functions. The operands to the `gpu.return` are the result values returned
     by an invocation of the `gpu.func`.
   }];
 
   let builders = [OpBuilder<(ins), [{ // empty}]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def GPU_TerminatorOp : GPU_Op<"terminator", [HasParent<"LaunchOp">,
                                              NoSideEffect, Terminator]>,
     Arguments<(ins)>, Results<(outs)> {
   let summary = "Terminator for GPU launch regions.";
   let description = [{
     A terminator operation for regions that appear in the body of `gpu.launch`
let description = [{
     the accumulation as operation, whereas the second version specifies the
     accumulation as code region. The accumulation operation must be one of:
     `add`, `and`, `max`, `min`, `mul`, `or`, `xor`.
 
     Either none or all work items of a workgroup need to execute this op
     in convergence.
   }];
   let regions = (region AnyRegion:$body);
-  let verifier = [{ return ::verifyAllReduce(*this); }];
   let assemblyFormat = [{ custom<AllReduceOperation>($op) $value $body attr-dict
                           `:` functional-type(operands, results) }];
+  let hasVerifier = 1;
 }
 
 def GPU_ShuffleOpXor  : I32EnumAttrCase<"XOR",  0, "xor">;
 def GPU_ShuffleOpDown : I32EnumAttrCase<"DOWN", 1, "down">;
 def GPU_ShuffleOpUp   : I32EnumAttrCase<"UP",   2, "up">;
 def GPU_ShuffleOpIdx  : I32EnumAttrCase<"IDX",  3, "idx">;
 
 def GPU_ShuffleMode : I32EnumAttr<"ShuffleMode",
let description = [{
     way to check at runtime whether this feature is supported.
 
     Writes from the host are guaranteed to be visible to device kernels that are
     launched afterwards. Writes from the device are guaranteed to be visible on
     the host after synchronizing with the device kernel completion.
   }];
 
   let assemblyFormat = "$value attr-dict `:` type($value)";
-  let verifier = [{ return success(); }];
 }
 
 def GPU_WaitOp : GPU_Op<"wait", [GPU_AsyncOpInterface]> {
   let summary = "Wait for async gpu ops to complete.";
   let description = [{
     This op synchronizes the host or the device with a list of dependent ops.
 
     If the op contains the `async` keyword, it returns a new async token which
let arguments = (ins Variadic<GPU_AsyncToken>:$asyncDependencies,
                    Arg<AnyMemRef, "", [MemWrite]>:$dst,
                    Arg<AnyMemRef, "", [MemRead]>:$src);
   let results = (outs Optional<GPU_AsyncToken>:$asyncToken);
 
   let assemblyFormat = [{
     custom<AsyncDependencies>(type($asyncToken), $asyncDependencies)
     $dst`,` $src `:` type($dst)`,` type($src) attr-dict
   }];
-  let verifier = [{ return ::verify(*this); }];
   let hasFolder = 1;
+  let hasVerifier = 1;
 }
 
 def GPU_MemsetOp : GPU_Op<"memset",
   [GPU_AsyncOpInterface, AllElementTypesMatch<["dst", "value"]>]> {
 
   let summary = "GPU memset operation";
 
   let description = [{
let arguments = (ins Variadic<GPU_AsyncToken>:$asyncDependencies,
                    Arg<AnyMemRef, "", [MemWrite]>:$dst,
                    Arg<AnyType, "">:$value);
   let results = (outs Optional<GPU_AsyncToken>:$asyncToken);
 
   let assemblyFormat = [{
     custom<AsyncDependencies>(type($asyncToken), $asyncDependencies)
     $dst`,` $value `:` type($dst)`,` type($value) attr-dict
   }];
-  // MemsetOp is fully verified by traits.
-  let verifier = [{ return success(); }];
   let hasFolder = 1;
 }
 
 def GPU_SubgroupMmaLoadMatrixOp : GPU_Op<"subgroup_mma_load_matrix",
     [MemoryEffects<[MemRead]>]>{
 
   let summary = "GPU warp synchronous matrix load";
 
let arguments = (ins Arg<MemRefOf<[F16, F32]>, "", [MemRead]>:$srcMemref,
                   Variadic<Index>:$indices,
                   IndexAttr:$leadDimension);
 
   let results = (outs GPU_MMAMatrix:$res);
 
   let assemblyFormat = [{
     $srcMemref`[`$indices`]` attr-dict `:` type($srcMemref) `->` type($res)
   }];
-
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def GPU_SubgroupMmaStoreMatrixOp : GPU_Op<"subgroup_mma_store_matrix",
     [MemoryEffects<[MemWrite]>]>{
 
   let summary = "GPU warp synchronous matrix store";
 
   let description = [{
def GPU_SubgroupMmaStoreMatrixOp : GPU_Op<"subgroup_mma_store_matrix",
   let arguments = (ins Arg<MMAMatrixOf<[F16, F32]>>:$src,
                   Arg<MemRefOf<[F16, F32]>, "",[MemWrite]>:$dstMemref,
                   Variadic<Index>:$indices,
                   IndexAttr:$leadDimension);
 
   let assemblyFormat = [{
     $src`,` $dstMemref`[`$indices`]` attr-dict `:` type($src)`,` type($dstMemref)
   }];
-
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def GPU_SubgroupMmaComputeOp : GPU_Op<"subgroup_mma_compute",
    [NoSideEffect, AllTypesMatch<["opC", "res"]>]>{
 
   let summary = "GPU warp synchronous matrix multiply accumulate";
 
   let description = [{
let arguments = (ins Arg<MMAMatrixOf<[F16, F32]>>:$opA,
                   Arg<MMAMatrixOf<[F16, F32]>>:$opB,
                   Arg<MMAMatrixOf<[F16, F32]>>:$opC);
 
   let results = (outs GPU_MMAMatrix:$res);
 
   let assemblyFormat = [{
     $opA`,` $opB`,` $opC attr-dict `:` type($opA)`,` type($opB) `->` type($res)
   }];
-
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 def GPU_SubgroupMmaConstantMatrixOp : GPU_Op<"subgroup_mma_constant_matrix",
     [NoSideEffect,
      TypesMatchWith<"value type matches element type of mma_matrix",
                     "res", "value",
                     "$_self.cast<gpu::MMAMatrixType>().getElementType()">]>{
 

mlir/include/mlir/Dialect/SCF/SCFOps.td

def SCF_Dialect : Dialect {
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for SCF dialect ops.
 class SCF_Op<string mnemonic, list<Trait> traits = []> :
     Op<SCF_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
-  //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 def ConditionOp : SCF_Op<"condition", [
   HasParent<"WhileOp">,
   DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>,
   NoSideEffect,
   Terminator
 ]> {
   let summary = "loop continuation condition";
   let description = [{
     This operation accepts the continuation (i.e., inverse of exit) condition
     of the `scf.while` construct. If its first argument is true, the "after"
     region of `scf.while` is executed, with the remaining arguments forwarded
     to the entry block of the region. Otherwise, the loop terminates.
   }];
 
   let arguments = (ins I1:$condition, Variadic<AnyType>:$args);
 
   let assemblyFormat =
       [{ `(` $condition `)` attr-dict ($args^ `:` type($args))? }];
-
-  // Override the default verifier, everything is checked by traits.
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // ExecuteRegionOp
 //===----------------------------------------------------------------------===//
 
 def ExecuteRegionOp : SCF_Op<"execute_region"> {
   let summary = "operation that executes its region exactly once";
def ExecuteRegionOp : SCF_Op<"execute_region"> {
 
   let results = (outs Variadic<AnyType>);
 
   let regions = (region AnyRegion:$region);
 
   let hasCanonicalizer = 1;
 
   let hasFolder = 0;
+  let hasVerifier = 1;
 }
 
 def ForOp : SCF_Op<"for",
       [DeclareOpInterfaceMethods<LoopLikeOpInterface>,
        DeclareOpInterfaceMethods<RegionBranchOpInterface>,
        SingleBlockImplicitTerminator<"scf::YieldOp">,
        RecursiveSideEffects]> {
   let summary = "for operation";
let extraClassDeclaration = [{
     /// Return operands used when entering the region at 'index'. These operands
     /// correspond to the loop iterator operands, i.e., those exclusing the
     /// induction variable. LoopOp only has one region, so 0 is the only valid
     /// value for `index`.
     OperandRange getSuccessorEntryOperands(unsigned index);
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def IfOp : SCF_Op<"if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getNumRegionInvocations",
                                   "getRegionInvocationBounds"]>,
        SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveSideEffects,
        NoRegionArguments]> {
let extraClassDeclaration = [{
     }
     Block* thenBlock();
     YieldOp thenYield();
     Block* elseBlock();
     YieldOp elseYield();
   }];
   let hasFolder = 1;
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def ParallelOp : SCF_Op<"parallel",
     [AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>,
      RecursiveSideEffects,
      SingleBlockImplicitTerminator<"scf::YieldOp">]> {
   let summary = "parallel for operation";
let extraClassDeclaration = [{
     ValueRange getInductionVars() {
       return getBody()->getArguments();
     }
     unsigned getNumLoops() { return getStep().size(); }
     unsigned getNumReductions() { return getInitVals().size(); }
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> {
   let summary = "reduce operation for parallel for";
   let description = [{
     "scf.reduce" is an operation occurring inside "scf.parallel" operations.
     It consists of one block with two arguments which have the same type as the
     operand of "scf.reduce".
def ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> {
   let builders = [
     OpBuilder<(ins "Value":$operand,
       CArg<"function_ref<void (OpBuilder &, Location, Value, Value)>",
            "nullptr">:$bodyBuilderFn)>
   ];
 
   let arguments = (ins AnyType:$operand);
   let regions = (region SizedRegion<1>:$reductionOperator);
+  let hasVerifier = 1;
 }
 
 def ReduceReturnOp :
     SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect,
                               Terminator]> {
   let summary = "terminator for reduce operation";
   let description = [{
     "scf.reduce.return" is a special terminator operation for the block inside
     "scf.reduce". It terminates the region. It should have the same type as
     the operand of "scf.reduce". Example for the custom format:
 
     ```mlir
     scf.reduce.return %res : f32
     ```
   }];
 
   let arguments = (ins AnyType:$result);
   let assemblyFormat = "$result attr-dict `:` type($result)";
+  let hasVerifier = 1;
 }
 
 def WhileOp : SCF_Op<"while",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
      RecursiveSideEffects]> {
   let summary = "a generic 'while' loop";
   let description = [{
     This operation represents a generic "while"/"do-while" loop that keeps
let extraClassDeclaration = [{
     OperandRange getSuccessorEntryOperands(unsigned index);
     ConditionOp getConditionOp();
     YieldOp getYieldOp();
     Block::BlockArgListType getBeforeArguments();
     Block::BlockArgListType getAfterArguments();
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator,
                                ParentOneOf<["ExecuteRegionOp, ForOp",
                                             "IfOp, ParallelOp, WhileOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "scf.yield" yields an SSA value from the SCF dialect op region and
     terminates the regions. The semantics of how the values are yielded is
     defined by the parent operation.
     If "scf.yield" has any operands, the operands must match the parent
     operation's results.
     If the parent operation defines no values, then the "scf.yield" may be
     left out in the custom syntax and the builders will insert one implicitly.
     Otherwise, it has to be present in the syntax to indicate which values are
     yielded.
   }];
 
   let arguments = (ins Variadic<AnyType>:$results);
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
   let assemblyFormat =
       [{  attr-dict ($results^ `:` type($results))? }];
-
-  // Override default verifier (defined in SCF_Op), no custom verification
-  // needed.
-  let verifier = ?;
 }
 
 #endif // MLIR_DIALECT_SCF_SCFOPS

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

auto walkResult = module.walk([&module](LaunchFuncOp launchOp) -> WalkResult {
     }
 
     return success();
   });
 
   return walkResult.wasInterrupted() ? failure() : success();
 }
 
-template <typename T>
-static LogicalResult verifyIndexOp(T op) {
-  auto dimension = op.dimension();
-  if (dimension != "x" && dimension != "y" && dimension != "z")
-    return op.emitError("dimension \"") << dimension << "\" is invalid";
-  return success();
-}
-
-static LogicalResult verifyAllReduce(gpu::AllReduceOp allReduce) {
-  if (allReduce.body().empty() != allReduce.op().hasValue())
-    return allReduce.emitError(
-        "expected either an op attribute or a non-empty body");
-  if (!allReduce.body().empty()) {
-    if (allReduce.body().getNumArguments() != 2)
-      return allReduce.emitError("expected two region arguments");
-    for (auto argument : allReduce.body().getArguments()) {
-      if (argument.getType() != allReduce.getType())
-        return allReduce.emitError("incorrect region argument type");
+LogicalResult gpu::AllReduceOp::verify() {
+  if (body().empty() != op().hasValue())
+    return emitError("expected either an op attribute or a non-empty body");
+  if (!body().empty()) {
+    if (body().getNumArguments() != 2)
+      return emitError("expected two region arguments");
+    for (auto argument : body().getArguments()) {
+      if (argument.getType() != getType())
+        return emitError("incorrect region argument type");
     }
     unsigned yieldCount = 0;
-    for (Block &block : allReduce.body()) {
+    for (Block &block : body()) {
       if (auto yield = dyn_cast<gpu::YieldOp>(block.getTerminator())) {
         if (yield.getNumOperands() != 1)
-          return allReduce.emitError("expected one gpu.yield operand");
-        if (yield.getOperand(0).getType() != allReduce.getType())
-          return allReduce.emitError("incorrect gpu.yield type");
+          return emitError("expected one gpu.yield operand");
+        if (yield.getOperand(0).getType() != getType())
+          return emitError("incorrect gpu.yield type");
         ++yieldCount;
       }
     }
     if (yieldCount == 0)
-      return allReduce.emitError("expected gpu.yield op in region");
+      return emitError("expected gpu.yield op in region");
   } else {
-    gpu::AllReduceOperation opName = *allReduce.op();
+    gpu::AllReduceOperation opName = *op();
     if ((opName == gpu::AllReduceOperation::AND ||
          opName == gpu::AllReduceOperation::OR ||
          opName == gpu::AllReduceOperation::XOR) &&
-        !allReduce.getType().isa<IntegerType>()) {
-      return allReduce.emitError()
-             << '`' << gpu::stringifyAllReduceOperation(opName) << '`'
-             << " accumulator is only compatible with Integer type";
+        !getType().isa<IntegerType>()) {
+      return emitError()
+             << '`' << gpu::stringifyAllReduceOperation(opName)
+             << "` accumulator is only compatible with Integer type";
     }
   }
   return success();
 }
 
 // TODO: Support optional custom attributes (without dialect prefix).
 static ParseResult parseAllReduceOperation(AsmParser &parser,
                                            AllReduceOperationAttr &attr) {

 KernelDim3 LaunchOp::getGridSizeOperandValues() {
   return KernelDim3{getOperand(0), getOperand(1), getOperand(2)};
 }
 
 KernelDim3 LaunchOp::getBlockSizeOperandValues() {
   return KernelDim3{getOperand(3), getOperand(4), getOperand(5)};
 }
 
-static LogicalResult verify(LaunchOp op) {
+LogicalResult LaunchOp::verify() {
   // Kernel launch takes kNumConfigOperands leading operands for grid/block
   // sizes and transforms them into kNumConfigRegionAttributes region arguments
   // for block/thread identifiers and grid/block sizes.
-  if (!op.body().empty()) {
-    if (op.body().getNumArguments() !=
-        LaunchOp::kNumConfigOperands + op.getNumOperands() -
-            (op.dynamicSharedMemorySize() ? 1 : 0))
-      return op.emitOpError("unexpected number of region arguments");
+  if (!body().empty()) {
+    if (body().getNumArguments() != LaunchOp::kNumConfigOperands +
+                                        getNumOperands() -
+                                        (dynamicSharedMemorySize() ? 1 : 0))
+      return emitOpError("unexpected number of region arguments");
   }
 
   // Block terminators without successors are expected to exit the kernel region
   // and must be `gpu.terminator`.
-  for (Block &block : op.body()) {
+  for (Block &block : body()) {
     if (block.empty())
       continue;
     if (block.back().getNumSuccessors() != 0)
       continue;
     if (!isa<gpu::TerminatorOp>(&block.back())) {
       return block.back()
           .emitError()
           .append("expected '", gpu::TerminatorOp::getOperationName(),
                   "' or a terminator with successors")
-          .attachNote(op.getLoc())
+          .attachNote(getLoc())
           .append("in '", LaunchOp::getOperationName(), "' body region");
     }
   }
 
   return success();
 }
 
 // Pretty-print the kernel grid/block size assignment as
KernelDim3 LaunchFuncOp::getGridSizeOperandValues() {
   return KernelDim3{operands[0], operands[1], operands[2]};
 }
 
 KernelDim3 LaunchFuncOp::getBlockSizeOperandValues() {
   auto operands = getOperands().drop_front(asyncDependencies().size());
   return KernelDim3{operands[3], operands[4], operands[5]};
 }
 
-static LogicalResult verify(LaunchFuncOp op) {
-  auto module = op->getParentOfType<ModuleOp>();
+LogicalResult LaunchFuncOp::verify() {
+  auto module = (*this)->getParentOfType<ModuleOp>();
   if (!module)
-    return op.emitOpError("expected to belong to a module");
+    return emitOpError("expected to belong to a module");
 
   if (!module->getAttrOfType<UnitAttr>(
           GPUDialect::getContainerModuleAttrName()))
-    return op.emitOpError(
-        "expected the closest surrounding module to have the '" +
-        GPUDialect::getContainerModuleAttrName() + "' attribute");
+    return emitOpError("expected the closest surrounding module to have the '" +
+                       GPUDialect::getContainerModuleAttrName() +
+                       "' attribute");
 
-  auto kernelAttr = op->getAttrOfType<SymbolRefAttr>(op.getKernelAttrName());
+  auto kernelAttr = (*this)->getAttrOfType<SymbolRefAttr>(getKernelAttrName());
   if (!kernelAttr)
-    return op.emitOpError("symbol reference attribute '" +
-                          op.getKernelAttrName() + "' must be specified");
+    return emitOpError("symbol reference attribute '" + getKernelAttrName() +
+                       "' must be specified");
 
   return success();
 }
 
 static ParseResult
 parseLaunchFuncOperands(OpAsmParser &parser,
                         SmallVectorImpl<OpAsmParser::OperandType> &argNames,
                         SmallVectorImpl<Type> &argTypes) {
LogicalResult GPUFuncOp::verifyBody() {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(gpu::ReturnOp returnOp) {
-  GPUFuncOp function = returnOp->getParentOfType<GPUFuncOp>();
+LogicalResult gpu::ReturnOp::verify() {
+  GPUFuncOp function = (*this)->getParentOfType<GPUFuncOp>();
 
   FunctionType funType = function.getType();
 
-  if (funType.getNumResults() != returnOp.operands().size())
-    return returnOp.emitOpError()
+  if (funType.getNumResults() != operands().size())
+    return emitOpError()
         .append("expected ", funType.getNumResults(), " result operands")
         .attachNote(function.getLoc())
         .append("return type declared here");
 
   for (const auto &pair : llvm::enumerate(
-           llvm::zip(function.getType().getResults(), returnOp.operands()))) {
+           llvm::zip(function.getType().getResults(), operands()))) {
     Type type;
     Value operand;
     std::tie(type, operand) = pair.value();
     if (type != operand.getType())
-      return returnOp.emitOpError() << "unexpected type `" << operand.getType()
-                                    << "' for operand #" << pair.index();
+      return emitOpError() << "unexpected type `" << operand.getType()
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPUModuleOp
 //===----------------------------------------------------------------------===//
 
static void print(OpAsmPrinter &p, GPUModuleOp op) {
   p.printRegion(op->getRegion(0), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // GPUMemcpyOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(MemcpyOp op) {
-  auto srcType = op.src().getType();
-  auto dstType = op.dst().getType();
+LogicalResult MemcpyOp::verify() {
+  auto srcType = src().getType();
+  auto dstType = dst().getType();
 
   if (getElementTypeOrSelf(srcType) != getElementTypeOrSelf(dstType))
-    return op.emitOpError("arguments have incompatible element type");
+    return emitOpError("arguments have incompatible element type");
 
   if (failed(verifyCompatibleShape(srcType, dstType)))
-    return op.emitOpError("arguments have incompatible shape");
+    return emitOpError("arguments have incompatible shape");
 
   return success();
 }
 
 static ParseResult parseAsyncDependencies(
     OpAsmParser &parser, Type &asyncTokenType,
     SmallVectorImpl<OpAsmParser::OperandType> &asyncDependencies) {
   auto loc = parser.getCurrentLocation();
static void printAsyncDependencies(OpAsmPrinter &printer, Operation *op,
   llvm::interleaveComma(asyncDependencies, printer);
   printer << "]";
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_SubgroupMmaLoadMatrixOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(SubgroupMmaLoadMatrixOp op) {
-  auto srcType = op.srcMemref().getType();
-  auto resType = op.res().getType();
+LogicalResult SubgroupMmaLoadMatrixOp::verify() {
+  auto srcType = srcMemref().getType();
+  auto resType = res().getType();
   auto resMatrixType = resType.cast<gpu::MMAMatrixType>();
   auto operand = resMatrixType.getOperand();
   auto srcMemrefType = srcType.cast<MemRefType>();
   auto srcMemSpace = srcMemrefType.getMemorySpaceAsInt();
 
   if (!srcMemrefType.getLayout().isIdentity())
-    return op.emitError("expected identity layout map for source memref");
+    return emitError("expected identity layout map for source memref");
 
   if (srcMemSpace != kGenericMemorySpace && srcMemSpace != kSharedMemorySpace &&
       srcMemSpace != kGlobalMemorySpace)
-    return op.emitError(
+    return emitError(
         "source memorySpace kGenericMemorySpace, kSharedMemorySpace or "
         "kGlobalMemorySpace only allowed");
 
   if (!operand.equals("AOp") && !operand.equals("BOp") &&
       !operand.equals("COp"))
-    return op.emitError("only AOp, BOp and COp can be loaded");
+    return emitError("only AOp, BOp and COp can be loaded");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_SubgroupMmaStoreMatrixOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(SubgroupMmaStoreMatrixOp op) {
-  auto srcType = op.src().getType();
-  auto dstType = op.dstMemref().getType();
+LogicalResult SubgroupMmaStoreMatrixOp::verify() {
+  auto srcType = src().getType();
+  auto dstType = dstMemref().getType();
   auto srcMatrixType = srcType.cast<gpu::MMAMatrixType>();
   auto dstMemrefType = dstType.cast<MemRefType>();
   auto dstMemSpace = dstMemrefType.getMemorySpaceAsInt();
   if (!dstMemrefType.getLayout().isIdentity())
-    return op.emitError("expected identity layout map for destination memref");
+    return emitError("expected identity layout map for destination memref");
 
   if (dstMemSpace != kGenericMemorySpace && dstMemSpace != kSharedMemorySpace &&
       dstMemSpace != kGlobalMemorySpace)
-    return op.emitError(
-        "destination memorySpace of kGenericMemorySpace, "
+    return emitError("destination memorySpace of kGenericMemorySpace, "
                      "kGlobalMemorySpace or kSharedMemorySpace only allowed");
 
   if (!srcMatrixType.getOperand().equals("COp"))
-    return op.emitError(
+    return emitError(
         "expected the operand matrix being stored to have 'COp' operand type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_SubgroupMmaComputeOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(SubgroupMmaComputeOp op) {
+LogicalResult SubgroupMmaComputeOp::verify() {
   enum OperandMap { A, B, C };
   SmallVector<MMAMatrixType, 3> opTypes;
-
-  auto populateOpInfo = [&opTypes, &op]() {
-    opTypes.push_back(op.opA().getType().cast<MMAMatrixType>());
-    opTypes.push_back(op.opB().getType().cast<MMAMatrixType>());
-    opTypes.push_back(op.opC().getType().cast<MMAMatrixType>());
-  };
-  populateOpInfo();
+  opTypes.push_back(opA().getType().cast<MMAMatrixType>());
+  opTypes.push_back(opB().getType().cast<MMAMatrixType>());
+  opTypes.push_back(opC().getType().cast<MMAMatrixType>());
 
   if (!opTypes[A].getOperand().equals("AOp") ||
       !opTypes[B].getOperand().equals("BOp") ||
       !opTypes[C].getOperand().equals("COp"))
-    return op.emitError("operands must be in the order AOp, BOp, COp");
+    return emitError("operands must be in the order AOp, BOp, COp");
 
   ArrayRef<int64_t> aShape, bShape, cShape;
   aShape = opTypes[A].getShape();
   bShape = opTypes[B].getShape();
   cShape = opTypes[C].getShape();
 
   if (aShape[1] != bShape[0] || aShape[0] != cShape[0] ||
       bShape[1] != cShape[1])
-    return op.emitError("operand shapes do not satisfy matmul constraints");
+    return emitError("operand shapes do not satisfy matmul constraints");
 
   return success();
 }
 
 /// This is a common class used for patterns of the form
 /// "someop(memrefcast) -> someop".  It folds the source of any memref.cast
 /// into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {

mlir/lib/Dialect/SCF/SCF.cpp

static void print(OpAsmPrinter &p, ExecuteRegionOp op) {
   p << ' ';
   p.printRegion(op.getRegion(),
                 /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/true);
 
   p.printOptionalAttrDict(op->getAttrs());
 }
 
-static LogicalResult verify(ExecuteRegionOp op) {
-  if (op.getRegion().empty())
-    return op.emitOpError("region needs to have at least one block");
-  if (op.getRegion().front().getNumArguments() > 0)
-    return op.emitOpError("region cannot have any arguments");
+LogicalResult ExecuteRegionOp::verify() {
+  if (getRegion().empty())
+    return emitOpError("region needs to have at least one block");
+  if (getRegion().front().getNumArguments() > 0)
+    return emitOpError("region cannot have any arguments");
   return success();
 }
 
 // Inline an ExecuteRegionOp if it only contains one block.
 //     "test.foo"() : () -> ()
 //      %v = scf.execute_region -> i64 {
 //        %x = "test.val"() : () -> i64
 //        scf.yield %x : i64
void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
   } else if (bodyBuilder) {
     OpBuilder::InsertionGuard guard(builder);
     builder.setInsertionPointToStart(&bodyBlock);
     bodyBuilder(builder, result.location, bodyBlock.getArgument(0),
                 bodyBlock.getArguments().drop_front());
   }
 }
 
-static LogicalResult verify(ForOp op) {
-  if (auto cst = op.getStep().getDefiningOp<arith::ConstantIndexOp>())
+LogicalResult ForOp::verify() {
+  if (auto cst = getStep().getDefiningOp<arith::ConstantIndexOp>())
     if (cst.value() <= 0)
-      return op.emitOpError("constant step operand must be positive");
+      return emitOpError("constant step operand must be positive");
 
   // Check that the body defines as single block argument for the induction
   // variable.
-  auto *body = op.getBody();
+  auto *body = getBody();
   if (!body->getArgument(0).getType().isIndex())
-    return op.emitOpError(
+    return emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 
-  auto opNumResults = op.getNumResults();
+  auto opNumResults = getNumResults();
   if (opNumResults == 0)
     return success();
   // If ForOp defines values, check that the number and types of
   // the defined values match ForOp initial iter operands and backedge
   // basic block arguments.
-  if (op.getNumIterOperands() != opNumResults)
-    return op.emitOpError(
+  if (getNumIterOperands() != opNumResults)
+    return emitOpError(
         "mismatch in number of loop-carried values and defined values");
-  if (op.getNumRegionIterArgs() != opNumResults)
-    return op.emitOpError(
+  if (getNumRegionIterArgs() != opNumResults)
+    return emitOpError(
         "mismatch in number of basic block args and defined values");
-  auto iterOperands = op.getIterOperands();
-  auto iterArgs = op.getRegionIterArgs();
-  auto opResults = op.getResults();
+  auto iterOperands = getIterOperands();
+  auto iterArgs = getRegionIterArgs();
+  auto opResults = getResults();
   unsigned i = 0;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
-      return op.emitOpError() << "types mismatch between " << i
-                              << "th iter operand and defined value";
+      return emitOpError() << "types mismatch between " << i
     if (std::get<1>(e).getType() != std::get<2>(e).getType())
-      return op.emitOpError() << "types mismatch between " << i
-                              << "th iter region arg and defined value";
+      return emitOpError() << "types mismatch between " << i
 
     i++;
   }
 
-  return RegionBranchOpInterface::verifyTypes(op);
+  return RegionBranchOpInterface::verifyTypes(*this);
 }
 
 /// Prints the initialization list in the form of
 ///   <prefix>(%inner = %outer, %inner2 = %outer2, <...>)
 /// where 'inner' values are assumed to be region arguments and 'outer' values
 /// are regular SSA values.
 static void printInitializationList(OpAsmPrinter &p,
                                     Block::BlockArgListType blocksArgs,

 }
 
 void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
                  function_ref<void(OpBuilder &, Location)> thenBuilder,
                  function_ref<void(OpBuilder &, Location)> elseBuilder) {
   build(builder, result, TypeRange(), cond, thenBuilder, elseBuilder);
 }
 
-static LogicalResult verify(IfOp op) {
-  if (op.getNumResults() != 0 && op.getElseRegion().empty())
-    return op.emitOpError("must have an else block if defining values");
+LogicalResult IfOp::verify() {
+  if (getNumResults() != 0 && getElseRegion().empty())
+    return emitOpError("must have an else block if defining values");
 
-  return RegionBranchOpInterface::verifyTypes(op);
+  return RegionBranchOpInterface::verifyTypes(*this);
 }
 
 static ParseResult parseIfOp(OpAsmParser &parser, OperationState &result) {
   // Create the regions for 'then'.
   result.regions.reserve(2);
   Region *thenRegion = result.addRegion();
   Region *elseRegion = result.addRegion();
 
void ParallelOp::build(
   function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> wrapper;
   if (bodyBuilderFn)
     wrapper = wrappedBuilderFn;
 
   build(builder, result, lowerBounds, upperBounds, steps, ValueRange(),
         wrapper);
 }
 
-static LogicalResult verify(ParallelOp op) {
+LogicalResult ParallelOp::verify() {
   // Check that there is at least one value in lowerBound, upperBound and step.
   // It is sufficient to test only step, because it is ensured already that the
   // number of elements in lowerBound, upperBound and step are the same.
-  Operation::operand_range stepValues = op.getStep();
+  Operation::operand_range stepValues = getStep();
   if (stepValues.empty())
-    return op.emitOpError(
+    return emitOpError(
         "needs at least one tuple element for lowerBound, upperBound and step");
 
   // Check whether all constant step values are positive.
   for (Value stepValue : stepValues)
     if (auto cst = stepValue.getDefiningOp<arith::ConstantIndexOp>())
       if (cst.value() <= 0)
-        return op.emitOpError("constant step operand must be positive");
+        return emitOpError("constant step operand must be positive");
 
   // Check that the body defines the same number of block arguments as the
   // number of tuple elements in step.
-  Block *body = op.getBody();
+  Block *body = getBody();
   if (body->getNumArguments() != stepValues.size())
-    return op.emitOpError()
-           << "expects the same number of induction variables: "
+    return emitOpError() << "expects the same number of induction variables: "
                          << body->getNumArguments()
                          << " as bound and step values: " << stepValues.size();
   for (auto arg : body->getArguments())
     if (!arg.getType().isIndex())
-      return op.emitOpError(
+      return emitOpError(
           "expects arguments for the induction variable to be of index type");
 
   // Check that the yield has no results
   Operation *yield = body->getTerminator();
   if (yield->getNumOperands() != 0)
     return yield->emitOpError() << "not allowed to have operands inside '"
                                 << ParallelOp::getOperationName() << "'";
 
   // Check that the number of results is the same as the number of ReduceOps.
   SmallVector<ReduceOp, 4> reductions(body->getOps<ReduceOp>());
-  auto resultsSize = op.getResults().size();
+  auto resultsSize = getResults().size();
   auto reductionsSize = reductions.size();
-  auto initValsSize = op.getInitVals().size();
+  auto initValsSize = getInitVals().size();
   if (resultsSize != reductionsSize)
-    return op.emitOpError()
-           << "expects number of results: " << resultsSize
-           << " to be the same as number of reductions: " << reductionsSize;
+    return emitOpError() << "expects number of results: " << resultsSize
+                         << " to be the same as number of reductions: "
+                         << reductionsSize;
   if (resultsSize != initValsSize)
-    return op.emitOpError()
-           << "expects number of results: " << resultsSize
-           << " to be the same as number of initial values: " << initValsSize;
+    return emitOpError() << "expects number of results: " << resultsSize
+                         << " to be the same as number of initial values: "
+                         << initValsSize;
 
   // Check that the types of the results and reductions are the same.
-  for (auto resultAndReduce : llvm::zip(op.getResults(), reductions)) {
+  for (auto resultAndReduce : llvm::zip(getResults(), reductions)) {
     auto resultType = std::get<0>(resultAndReduce).getType();
     auto reduceOp = std::get<1>(resultAndReduce);
     auto reduceType = reduceOp.getOperand().getType();
     if (resultType != reduceType)
       return reduceOp.emitOpError()
              << "expects type of reduce: " << reduceType
              << " to be the same as result type: " << resultType;
   }
void ReduceOp::build(
   Region *bodyRegion = result.addRegion();
   Block *body = builder.createBlock(bodyRegion, {}, ArrayRef<Type>{type, type},
                                     {result.location, result.location});
   if (bodyBuilderFn)
     bodyBuilderFn(builder, result.location, body->getArgument(0),
                   body->getArgument(1));
 }
 
-static LogicalResult verify(ReduceOp op) {
+LogicalResult ReduceOp::verify() {
   // The region of a ReduceOp has two arguments of the same type as its operand.
-  auto type = op.getOperand().getType();
-  Block &block = op.getReductionOperator().front();
+  auto type = getOperand().getType();
+  Block &block = getReductionOperator().front();
   if (block.empty())
-    return op.emitOpError("the block inside reduce should not be empty");
+    return emitOpError("the block inside reduce should not be empty");
   if (block.getNumArguments() != 2 ||
       llvm::any_of(block.getArguments(), [&](const BlockArgument &arg) {
         return arg.getType() != type;
       }))
-    return op.emitOpError()
-           << "expects two arguments to reduce block of type " << type;
+    return emitOpError() << "expects two arguments to reduce block of type "
+                         << type;
 
   // Check that the block is terminated by a ReduceReturnOp.
   if (!isa<ReduceReturnOp>(block.getTerminator()))
-    return op.emitOpError("the block inside reduce should be terminated with a "
-                          "'scf.reduce.return' op");
+    return emitOpError("the block inside reduce should be terminated with a "
 
   return success();
 }
 
 static ParseResult parseReduceOp(OpAsmParser &parser, OperationState &result) {
   // Parse an opening `(` followed by the reduced value followed by `)`
   OpAsmParser::OperandType operand;
   if (parser.parseLParen() || parser.parseOperand(operand) ||
static void print(OpAsmPrinter &p, ReduceOp op) {
   p << " : " << op.getOperand().getType() << ' ';
   p.printRegion(op.getReductionOperator());
 }
 
 //===----------------------------------------------------------------------===//
 // ReduceReturnOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReduceReturnOp op) {
+LogicalResult ReduceReturnOp::verify() {
   // The type of the return value should be the same type as the type of the
   // operand of the enclosing ReduceOp.
-  auto reduceOp = cast<ReduceOp>(op->getParentOp());
+  auto reduceOp = cast<ReduceOp>((*this)->getParentOp());
   Type reduceType = reduceOp.getOperand().getType();
-  if (reduceType != op.getResult().getType())
-    return op.emitOpError() << "needs to have type " << reduceType
-                            << " (the type of the enclosing ReduceOp)";
+  if (reduceType != getResult().getType())
+    return emitOpError() << "needs to have type " << reduceType
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // WhileOp
 //===----------------------------------------------------------------------===//
 
 OperandRange WhileOp::getSuccessorEntryOperands(unsigned index) {
if (auto yield = dyn_cast_or_null<TerminatorTy>(terminatorOperation))
     return yield;
 
   auto diag = op.emitOpError(errorMessage);
   if (terminatorOperation)
     diag.attachNote(terminatorOperation->getLoc()) << "terminator here";
   return nullptr;
 }
 
-static LogicalResult verify(scf::WhileOp op) {
-  if (failed(RegionBranchOpInterface::verifyTypes(op)))
+LogicalResult scf::WhileOp::verify() {
+  if (failed(RegionBranchOpInterface::verifyTypes(*this)))
     return failure();
 
   auto beforeTerminator = verifyAndGetTerminator<scf::ConditionOp>(
-      op, op.getBefore(),
+      *this, getBefore(),
       "expects the 'before' region to terminate with 'scf.condition'");
   if (!beforeTerminator)
     return failure();
 
   auto afterTerminator = verifyAndGetTerminator<scf::YieldOp>(
-      op, op.getAfter(),
+      *this, getAfter(),
       "expects the 'after' region to terminate with 'scf.yield'");
   return success(afterTerminator != nullptr);
 }
 
 namespace {
 /// Replace uses of the condition within the do block with true, since otherwise
 /// the block would not be evaluated.
 ///