[mlir][NFC] Update OpenACC/OpenMP operations to use `hasVerifier` instead of `verifier`

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

Depends on D118821

[clementval]

LGTM on the OpenACC part.

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

 // AccCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenACC/AccCommon.td"
 
 // Base class for OpenACC dialect ops.
 class OpenACC_Op<string mnemonic, list<Trait> traits = []> :
   Op<OpenACC_Dialect, mnemonic, traits> {
 
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 // Reduction operation enumeration.
 def OpenACC_ReductionOpAdd     : I32EnumAttrCase<"redop_add", 0>;
 def OpenACC_ReductionOpMul     : I32EnumAttrCase<"redop_mul", 1>;
 def OpenACC_ReductionOpMax     : I32EnumAttrCase<"redop_max", 2>;
 def OpenACC_ReductionOpMin     : I32EnumAttrCase<"redop_min", 3>;
let extraClassDeclaration = [{
     static StringRef getFirstPrivateKeyword() { return "firstprivate"; }
 
     /// The number of data operands.
     unsigned getNumDataOperands();
 
     /// The i-th data operand passed.
     Value getDataOperand(unsigned i);
   }];
-
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.6.5 data Construct
 //===----------------------------------------------------------------------===//
 
 def OpenACC_DataOp : OpenACC_Op<"data",
     [AttrSizedOperandSegments]> {
let assemblyFormat = [{
     ( `create_zero` `(` $createZeroOperands^ `:`
         type($createZeroOperands) `)` )?
     ( `no_create` `(` $noCreateOperands^ `:` type($noCreateOperands) `)` )?
     ( `present` `(` $presentOperands^ `:` type($presentOperands) `)` )?
     ( `deviceptr` `(` $deviceptrOperands^ `:` type($deviceptrOperands) `)` )?
     ( `attach` `(` $attachOperands^ `:` type($attachOperands) `)` )?
     $region attr-dict-with-keyword
   }];
+  let hasVerifier = 1;
 }
 
 def OpenACC_TerminatorOp : OpenACC_Op<"terminator", [Terminator]> {
   let summary = "Generic terminator for OpenACC regions";
 
   let description = [{
     A terminator operation for regions that appear in the body of OpenACC
     operation. Generic OpenACC construct regions are not expected to return any
     value so the terminator takes no operands. The terminator op returns control
     to the enclosing op.
   }];
 
-  let verifier = ?;
-
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // 2.6.6 Enter Data Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_EnterDataOp : OpenACC_Op<"enter_data", [AttrSizedOperandSegments]> {
let assemblyFormat = [{
     ( `create` `(` $createOperands^ `:` type($createOperands) `)` )?
     ( `create_zero` `(` $createZeroOperands^ `:`
         type($createZeroOperands) `)` )?
     ( `attach` `(` $attachOperands^ `:` type($attachOperands) `)` )?
     attr-dict-with-keyword
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.6.6 Exit Data Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_ExitDataOp : OpenACC_Op<"exit_data", [AttrSizedOperandSegments]> {
   let summary = "exit data operation";
let assemblyFormat = [{
     ( `wait` `(` $waitOperands^ `:` type($waitOperands) `)` )?
     ( `copyout` `(` $copyoutOperands^ `:` type($copyoutOperands) `)` )?
     ( `delete` `(` $deleteOperands^ `:` type($deleteOperands) `)` )?
     ( `detach` `(` $detachOperands^ `:` type($detachOperands) `)` )?
     attr-dict-with-keyword
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.9 loop Construct
 //===----------------------------------------------------------------------===//
 
 def OpenACC_LoopOp : OpenACC_Op<"loop",
       [AttrSizedOperandSegments,
let extraClassDeclaration = [{
     static StringRef getGangNumKeyword() { return "num"; }
     static StringRef getGangStaticKeyword() { return "static"; }
     static StringRef getVectorKeyword() { return "vector"; }
     static StringRef getWorkerKeyword() { return "worker"; }
     static StringRef getTileKeyword() { return "tile"; }
     static StringRef getPrivateKeyword() { return "private"; }
     static StringRef getReductionKeyword() { return "reduction"; }
   }];
-
-  let verifier = [{ return ::verifyLoopOp(*this); }];
+  let hasVerifier = 1;
 }
 
 // Yield operation for the acc.loop and acc.parallel operations.
 def OpenACC_YieldOp : OpenACC_Op<"yield", [Terminator,
     ParentOneOf<["ParallelOp, LoopOp"]>]> {
   let summary = "Acc yield and termination operation";
 
   let description = [{
     `acc.yield` is a special terminator operation for block inside regions in
     acc ops (parallel and loop). It returns values to the immediately enclosing
     acc op.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
-  let verifier = ?;
-
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 //===----------------------------------------------------------------------===//
 // 2.14.1. Init Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_InitOp : OpenACC_Op<"init", [AttrSizedOperandSegments]> {
let arguments = (ins Variadic<AnyInteger>:$deviceTypeOperands,
                        Optional<IntOrIndex>:$deviceNumOperand,
                        Optional<I1>:$ifCond);
 
   let assemblyFormat = [{
     ( `device_type` `(` $deviceTypeOperands^ `:` type($deviceTypeOperands) `)` )?
     ( `device_num` `(` $deviceNumOperand^ `:` type($deviceNumOperand) `)` )?
     ( `if` `(` $ifCond^ `)` )? attr-dict-with-keyword
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.14.2. Shutdown
 //===----------------------------------------------------------------------===//
 
 def OpenACC_ShutdownOp : OpenACC_Op<"shutdown", [AttrSizedOperandSegments]> {
   let summary = "shutdown operation";
let arguments = (ins Variadic<AnyInteger>:$deviceTypeOperands,
                        Optional<IntOrIndex>:$deviceNumOperand,
                        Optional<I1>:$ifCond);
 
   let assemblyFormat = [{
     ( `device_type` `(` $deviceTypeOperands^ `:` type($deviceTypeOperands) `)` )?
     ( `device_num` `(` $deviceNumOperand^ `:` type($deviceNumOperand) `)` )?
     ( `if` `(` $ifCond^ `)` )? attr-dict-with-keyword
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.14.4. Update Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_UpdateOp : OpenACC_Op<"update", [AttrSizedOperandSegments]> {
   let summary = "update operation";
( `device_type` `(` $deviceTypeOperands^ `:`
         type($deviceTypeOperands) `)` )?
     ( `wait` `(` $waitOperands^ `:` type($waitOperands) `)` )?
     ( `host` `(` $hostOperands^ `:` type($hostOperands) `)` )?
     ( `device` `(` $deviceOperands^ `:` type($deviceOperands) `)` )?
     attr-dict-with-keyword
   }];
 
   let hasCanonicalizer = 1;
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.16.3. Wait Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_WaitOp : OpenACC_Op<"wait", [AttrSizedOperandSegments]> {
   let summary = "wait operation";
let arguments = (ins Variadic<IntOrIndex>:$waitOperands,
                        Optional<I1>:$ifCond);
 
   let assemblyFormat = [{
     ( `(` $waitOperands^ `:` type($waitOperands) `)` )?
     ( `async` `(` $asyncOperand^ `:` type($asyncOperand) `)` )?
     ( `wait_devnum` `(` $waitDevnum^ `:` type($waitDevnum) `)` )?
     ( `if` `(` $ifCond^ `)` )? attr-dict-with-keyword
   }];
+  let hasVerifier = 1;
 }
 
 #endif // OPENACC_OPS

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

def ParallelOp : OpenMP_Op<"parallel", [AttrSizedOperandSegments,
 
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
   let parser = [{ return parseParallelOp(parser, result); }];
   let printer = [{ return printParallelOp(p, *this); }];
-  let verifier = [{ return ::verifyParallelOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def TerminatorOp : OpenMP_Op<"terminator", [Terminator]> {
   let summary = "terminator for OpenMP regions";
   let description = [{
     A terminator operation for regions that appear in the body of OpenMP
     operation.  These regions are not expected to return any value so the
     terminator takes no operands. The terminator op returns control to the
let arguments = (ins Variadic<AnyType>:$private_vars,
                        Variadic<AnyType>:$allocate_vars,
                        Variadic<AnyType>:$allocators_vars,
                        UnitAttr:$nowait);
 
   let regions = (region SizedRegion<1>:$region);
 
   let parser = [{ return parseSectionsOp(parser, result); }];
   let printer = [{ return printSectionsOp(p, *this); }];
-  let verifier = [{ return verifySectionsOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.9.2 Workshare Loop Construct
 //===----------------------------------------------------------------------===//
 
 def WsLoopOp : OpenMP_Op<"wsloop", [AttrSizedOperandSegments,
                          AllTypesMatch<["lowerBound", "upperBound", "step"]>]> {
let extraClassDeclaration = [{
     /// Returns the number of loops in the workshape loop nest.
     unsigned getNumLoops() { return lowerBound().size(); }
 
     /// Returns the number of reduction variables.
     unsigned getNumReductionVars() { return reduction_vars().size(); }
   }];
   let parser = [{ return parseWsLoopOp(parser, result); }];
   let printer = [{ return printWsLoopOp(p, *this); }];
-  let verifier = [{ return ::verifyWsLoopOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def YieldOp : OpenMP_Op<"yield",
     [NoSideEffect, ReturnLike, Terminator,
      ParentOneOf<["WsLoopOp", "ReductionDeclareOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "omp.yield" yields SSA values from the OpenMP dialect op region and
def CriticalDeclareOp : OpenMP_Op<"critical.declare", [Symbol]> {
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name,
                        DefaultValuedAttr<I64Attr, "0">:$hint);
 
   let assemblyFormat = [{
     $sym_name custom<SynchronizationHint>($hint) attr-dict
   }];
-
-  let verifier = "return verifyCriticalDeclareOp(*this);";
+  let hasVerifier = 1;
 }
 
 
 def CriticalOp : OpenMP_Op<"critical"> {
   let summary = "critical construct";
   let description = [{
     The critical construct imposes a restriction on the associated structured
     block (region) to be executed by only a single thread at a time.
   }];
 
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$name);
 
   let regions = (region AnyRegion:$region);
 
   let assemblyFormat = [{
     (`(` $name^ `)`)? $region attr-dict
   }];
-
-  let verifier = "return ::verifyCriticalOp(*this);";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.17.2 barrier Construct
 //===----------------------------------------------------------------------===//
 
 def BarrierOp : OpenMP_Op<"barrier"> {
   let summary = "barrier construct";
let arguments = (ins OptionalAttr<ClauseDependAttr>:$depend_type_val,
              Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
              Variadic<AnyType>:$depend_vec_vars);
 
   let assemblyFormat = [{
     ( `depend_type` `` $depend_type_val^ )?
     ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )?
     attr-dict
   }];
-
-  let verifier = "return ::verifyOrderedOp(*this);";
+  let hasVerifier = 1;
 }
 
 def OrderedRegionOp : OpenMP_Op<"ordered_region"> {
   let summary = "ordered construct with region";
   let description = [{
     The ordered construct with region specifies a structured block in a
     worksharing-loop, SIMD, or worksharing-loop SIMD region that is executed in
     the order of the loop iterations.
 
     The `simd` attribute corresponds to the SIMD clause specified. If it is not
     present, it behaves as if the THREADS clause is specified or no clause is
     specified.
   }];
 
   let arguments = (ins UnitAttr:$simd);
 
   let regions = (region AnyRegion:$region);
 
   let assemblyFormat = [{ ( `simd` $simd^ )? $region attr-dict}];
-
-  let verifier = "return ::verifyOrderedRegionOp(*this);";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.17.5 taskwait Construct
 //===----------------------------------------------------------------------===//
 
 def TaskwaitOp : OpenMP_Op<"taskwait"> {
   let summary = "taskwait construct";
def AtomicReadOp : OpenMP_Op<"atomic.read"> {
   }];
 
   let arguments = (ins OpenMP_PointerLikeType:$x,
                        OpenMP_PointerLikeType:$v,
                        DefaultValuedAttr<I64Attr, "0">:$hint,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order);
   let parser = [{ return parseAtomicReadOp(parser, result); }];
   let printer = [{ return printAtomicReadOp(p, *this); }];
-  let verifier = [{ return verifyAtomicReadOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def AtomicWriteOp : OpenMP_Op<"atomic.write"> {
 
   let summary = "performs an atomic write";
 
   let description = [{
     This operation performs an atomic write.
def AtomicWriteOp : OpenMP_Op<"atomic.write"> {
   }];
 
   let arguments = (ins OpenMP_PointerLikeType:$address,
                        AnyType:$value,
                        DefaultValuedAttr<I64Attr, "0">:$hint,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order);
   let parser = [{ return parseAtomicWriteOp(parser, result); }];
   let printer = [{ return printAtomicWriteOp(p, *this); }];
-  let verifier = [{ return verifyAtomicWriteOp(*this); }];
+  let hasVerifier = 1;
 }
 
 // TODO: autogenerate from OMP.td in future if possible.
 def ATOMIC_BINOP_KIND_ADD : I64EnumAttrCase<"ADD", 0>;
 def ATOMIC_BINOP_KIND_MUL : I64EnumAttrCase<"MUL", 1>;
 def ATOMIC_BINOP_KIND_SUB : I64EnumAttrCase<"SUB", 2>;
 def ATOMIC_BINOP_KIND_DIV : I64EnumAttrCase<"DIV", 3>;
 def ATOMIC_BINOP_KIND_AND : I64EnumAttrCase<"AND", 4>;
def AtomicUpdateOp : OpenMP_Op<"atomic.update"> {
   let arguments = (ins OpenMP_PointerLikeType:$x,
                        AnyType:$expr,
                        UnitAttr:$isXBinopExpr,
                        AtomicBinOpKindAttr:$binop,
                        DefaultValuedAttr<I64Attr, "0">:$hint,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order);
   let parser = [{ return parseAtomicUpdateOp(parser, result); }];
   let printer = [{ return printAtomicUpdateOp(p, *this); }];
-  let verifier = [{ return verifyAtomicUpdateOp(*this); }];
+  let hasVerifier = 1;
 }
 
 def AtomicCaptureOp : OpenMP_Op<"atomic.capture",
     [SingleBlockImplicitTerminator<"TerminatorOp">]> {
   let summary = "performs an atomic capture";
   let description = [{
     This operation performs an atomic capture.
 
def AtomicCaptureOp : OpenMP_Op<"atomic.capture",
 
   }];
 
   let arguments = (ins DefaultValuedAttr<I64Attr, "0">:$hint,
                        OptionalAttr<MemoryOrderKind>:$memory_order);
   let regions = (region SizedRegion<1>:$region);
   let parser = [{ return parseAtomicCaptureOp(parser, result); }];
   let printer = [{ return printAtomicCaptureOp(p, *this); }];
-  let verifier = [{ return verifyAtomicCaptureOp(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.7 declare reduction Directive
 //===----------------------------------------------------------------------===//
 
 def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol]> {
   let summary = "declares a reduction kind";
def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol]> {
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name,
                        TypeAttr:$type);
 
   let regions = (region AnyRegion:$initializerRegion,
                         AnyRegion:$reductionRegion,
                         AnyRegion:$atomicReductionRegion);
-  let verifier = "return ::verifyReductionDeclareOp(*this);";
 
   let assemblyFormat = "$sym_name `:` $type attr-dict-with-keyword "
                        "`init` $initializerRegion "
                        "`combiner` $reductionRegion "
                        "custom<AtomicReductionRegion>($atomicReductionRegion)";
 
   let extraClassDeclaration = [{
     PointerLikeType getAccumulatorType() {
       if (atomicReductionRegion().empty())
         return {};
 
       return atomicReductionRegion().front().getArgument(0).getType();
     }
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.4 reduction clause
 //===----------------------------------------------------------------------===//
 
 def ReductionOp : OpenMP_Op<"reduction", [
     TypesMatchWith<"value types matches accumulator element type",
                    "accumulator", "operand",
                  "$_self.cast<::mlir::omp::PointerLikeType>().getElementType()">
   ]> {
   let summary = "reduction construct";
   let description = [{
     Indicates the value that is produced by the current reduction-participating
     entity for a reduction requested in some ancestor. The reduction is
     identified by the accumulator, but the value of the accumulator may not be
     updated immediately.
   }];
 
   let arguments= (ins AnyType:$operand, OpenMP_PointerLikeType:$accumulator);
   let assemblyFormat =
     "$operand `,` $accumulator attr-dict `:` type($accumulator)";
-  let verifier = "return ::verifyReductionOp(*this);";
+  let hasVerifier = 1;
 }
 
 #endif // OPENMP_OPS

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

printer.printRegion(op.region(),
                       /*printEntryBlockArgs=*/false,
                       /*printBlockTerminators=*/true);
 
   printer.printOptionalAttrDictWithKeyword(
       op->getAttrs(), {LoopOp::getExecutionMappingAttrName(),
                        LoopOp::getOperandSegmentSizeAttr()});
 }
 
-static LogicalResult verifyLoopOp(acc::LoopOp loopOp) {
+LogicalResult acc::LoopOp::verify() {
   // auto, independent and seq attribute are mutually exclusive.
-  if ((loopOp.auto_() && (loopOp.independent() || loopOp.seq())) ||
-      (loopOp.independent() && loopOp.seq())) {
-    loopOp.emitError("only one of " + acc::LoopOp::getAutoAttrName() + ", " +
+  if ((auto_() && (independent() || seq())) || (independent() && seq())) {
+    return emitError("only one of " + acc::LoopOp::getAutoAttrName() + ", " +
                      acc::LoopOp::getIndependentAttrName() + ", " +
                      acc::LoopOp::getSeqAttrName() +
                      " can be present at the same time");
-    return failure();
   }
 
   // Gang, worker and vector are incompatible with seq.
-  if (loopOp.seq() && loopOp.exec_mapping() != OpenACCExecMapping::NONE) {
-    loopOp.emitError("gang, worker or vector cannot appear with the seq attr");
-    return failure();
-  }
+  if (seq() && exec_mapping() != OpenACCExecMapping::NONE)
+    return emitError("gang, worker or vector cannot appear with the seq attr");
 
   // Check non-empty body().
-  if (loopOp.region().empty()) {
-    loopOp.emitError("expected non-empty body.");
-    return failure();
-  }
+  if (region().empty())
+    return emitError("expected non-empty body.");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // DataOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::DataOp dataOp) {
+LogicalResult acc::DataOp::verify() {
   // 2.6.5. Data Construct restriction
   // At least one copy, copyin, copyout, create, no_create, present, deviceptr,
   // attach, or default clause must appear on a data construct.
-  if (dataOp.getOperands().empty() && !dataOp.defaultAttr())
-    return dataOp.emitError("at least one operand or the default attribute "
-                            "must appear on the data operation");
+  if (getOperands().empty() && !defaultAttr())
+    return emitError("at least one operand or the default attribute "
   return success();
 }
 
 unsigned DataOp::getNumDataOperands() {
   return copyOperands().size() + copyinOperands().size() +
          copyinReadonlyOperands().size() + copyoutOperands().size() +
          copyoutZeroOperands().size() + createOperands().size() +
          createZeroOperands().size() + noCreateOperands().size() +
          presentOperands().size() + deviceptrOperands().size() +
          attachOperands().size();
 }
 
 Value DataOp::getDataOperand(unsigned i) {
   unsigned numOptional = ifCond() ? 1 : 0;
   return getOperand(numOptional + i);
 }
 
 //===----------------------------------------------------------------------===//
 // ExitDataOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::ExitDataOp op) {
+LogicalResult acc::ExitDataOp::verify() {
   // 2.6.6. Data Exit Directive restriction
   // At least one copyout, delete, or detach clause must appear on an exit data
   // directive.
-  if (op.copyoutOperands().empty() && op.deleteOperands().empty() &&
-      op.detachOperands().empty())
-    return op.emitError(
+  if (copyoutOperands().empty() && deleteOperands().empty() &&
+      detachOperands().empty())
+    return emitError(
         "at least one operand in copyout, delete or detach must appear on the "
         "exit data operation");
 
   // The async attribute represent the async clause without value. Therefore the
   // attribute and operand cannot appear at the same time.
-  if (op.asyncOperand() && op.async())
-    return op.emitError("async attribute cannot appear with asyncOperand");
+  if (asyncOperand() && async())
+    return emitError("async attribute cannot appear with asyncOperand");
 
   // The wait attribute represent the wait clause without values. Therefore the
   // attribute and operands cannot appear at the same time.
-  if (!op.waitOperands().empty() && op.wait())
-    return op.emitError("wait attribute cannot appear with waitOperands");
+  if (!waitOperands().empty() && wait())
+    return emitError("wait attribute cannot appear with waitOperands");
 
-  if (op.waitDevnum() && op.waitOperands().empty())
-    return op.emitError("wait_devnum cannot appear without waitOperands");
+  if (waitDevnum() && waitOperands().empty())
+    return emitError("wait_devnum cannot appear without waitOperands");
 
   return success();
 }
 
 unsigned ExitDataOp::getNumDataOperands() {
   return copyoutOperands().size() + deleteOperands().size() +
          detachOperands().size();
 }
void ExitDataOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                              MLIRContext *context) {
   results.add<RemoveConstantIfCondition<ExitDataOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // EnterDataOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::EnterDataOp op) {
+LogicalResult acc::EnterDataOp::verify() {
   // 2.6.6. Data Enter Directive restriction
   // At least one copyin, create, or attach clause must appear on an enter data
   // directive.
-  if (op.copyinOperands().empty() && op.createOperands().empty() &&
-      op.createZeroOperands().empty() && op.attachOperands().empty())
-    return op.emitError(
+  if (copyinOperands().empty() && createOperands().empty() &&
+      createZeroOperands().empty() && attachOperands().empty())
+    return emitError(
         "at least one operand in copyin, create, "
         "create_zero or attach must appear on the enter data operation");
 
   // The async attribute represent the async clause without value. Therefore the
   // attribute and operand cannot appear at the same time.
-  if (op.asyncOperand() && op.async())
-    return op.emitError("async attribute cannot appear with asyncOperand");
+  if (asyncOperand() && async())
+    return emitError("async attribute cannot appear with asyncOperand");
 
   // The wait attribute represent the wait clause without values. Therefore the
   // attribute and operands cannot appear at the same time.
-  if (!op.waitOperands().empty() && op.wait())
-    return op.emitError("wait attribute cannot appear with waitOperands");
+  if (!waitOperands().empty() && wait())
+    return emitError("wait attribute cannot appear with waitOperands");
 
-  if (op.waitDevnum() && op.waitOperands().empty())
-    return op.emitError("wait_devnum cannot appear without waitOperands");
+  if (waitDevnum() && waitOperands().empty())
+    return emitError("wait_devnum cannot appear without waitOperands");
 
   return success();
 }
 
 unsigned EnterDataOp::getNumDataOperands() {
   return copyinOperands().size() + createOperands().size() +
          createZeroOperands().size() + attachOperands().size();
 }
void EnterDataOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   results.add<RemoveConstantIfCondition<EnterDataOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // InitOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::InitOp initOp) {
-  Operation *currOp = initOp;
-  while ((currOp = currOp->getParentOp())) {
+LogicalResult acc::InitOp::verify() {
+  Operation *currOp = *this;
+  while ((currOp = currOp->getParentOp()))
     if (isComputeOperation(currOp))
-      return initOp.emitOpError("cannot be nested in a compute operation");
-  }
+      return emitOpError("cannot be nested in a compute operation");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShutdownOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::ShutdownOp op) {
-  Operation *currOp = op;
-  while ((currOp = currOp->getParentOp())) {
+LogicalResult acc::ShutdownOp::verify() {
+  Operation *currOp = *this;
+  while ((currOp = currOp->getParentOp()))
     if (isComputeOperation(currOp))
-      return op.emitOpError("cannot be nested in a compute operation");
-  }
+      return emitOpError("cannot be nested in a compute operation");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // UpdateOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::UpdateOp updateOp) {
+LogicalResult acc::UpdateOp::verify() {
   // At least one of host or device should have a value.
-  if (updateOp.hostOperands().empty() && updateOp.deviceOperands().empty())
-    return updateOp.emitError("at least one value must be present in"
-                              " hostOperands or deviceOperands");
+  if (hostOperands().empty() && deviceOperands().empty())
+    return emitError(
+        "at least one value must be present in hostOperands or deviceOperands");
 
   // The async attribute represent the async clause without value. Therefore the
   // attribute and operand cannot appear at the same time.
-  if (updateOp.asyncOperand() && updateOp.async())
-    return updateOp.emitError("async attribute cannot appear with "
-                              " asyncOperand");
+  if (asyncOperand() && async())
+    return emitError("async attribute cannot appear with asyncOperand");
 
   // The wait attribute represent the wait clause without values. Therefore the
   // attribute and operands cannot appear at the same time.
-  if (!updateOp.waitOperands().empty() && updateOp.wait())
-    return updateOp.emitError("wait attribute cannot appear with waitOperands");
+  if (!waitOperands().empty() && wait())
+    return emitError("wait attribute cannot appear with waitOperands");
 
-  if (updateOp.waitDevnum() && updateOp.waitOperands().empty())
-    return updateOp.emitError("wait_devnum cannot appear without waitOperands");
+  if (waitDevnum() && waitOperands().empty())
+    return emitError("wait_devnum cannot appear without waitOperands");
 
   return success();
 }
 
 unsigned UpdateOp::getNumDataOperands() {
   return hostOperands().size() + deviceOperands().size();
 }
 
void UpdateOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.add<RemoveConstantIfCondition<UpdateOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // WaitOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(acc::WaitOp waitOp) {
+LogicalResult acc::WaitOp::verify() {
   // The async attribute represent the async clause without value. Therefore the
   // attribute and operand cannot appear at the same time.
-  if (waitOp.asyncOperand() && waitOp.async())
-    return waitOp.emitError("async attribute cannot appear with asyncOperand");
+  if (asyncOperand() && async())
+    return emitError("async attribute cannot appear with asyncOperand");
 
-  if (waitOp.waitDevnum() && waitOp.waitOperands().empty())
-    return waitOp.emitError("wait_devnum cannot appear without waitOperands");
+  if (waitDevnum() && waitOperands().empty())
+    return emitError("wait_devnum cannot appear without waitOperands");
 
   return success();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenACC/OpenACCOps.cpp.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/OpenACC/OpenACCOpsAttributes.cpp.inc"

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

static void printAllocateAndAllocator(OpAsmPrinter &p,
   p << "allocate(";
   for (unsigned i = 0; i < varsAllocate.size(); ++i) {
     std::string separator = i == varsAllocate.size() - 1 ? ") " : ", ";
     p << varsAllocator[i] << " : " << varsAllocator[i].getType() << " -> ";
     p << varsAllocate[i] << " : " << varsAllocate[i].getType() << separator;
   }
 }
 
-static LogicalResult verifyParallelOp(ParallelOp op) {
-  if (op.allocate_vars().size() != op.allocators_vars().size())
-    return op.emitError(
+LogicalResult ParallelOp::verify() {
+  if (allocate_vars().size() != allocators_vars().size())
+    return emitError(
         "expected equal sizes for allocate and allocator variables");
   return success();
 }
 
 static void printParallelOp(OpAsmPrinter &p, ParallelOp op) {
   p << " ";
   if (auto ifCond = op.if_expr_var())
     p << "if(" << ifCond << " : " << ifCond.getType() << ") ";
static void printSectionsOp(OpAsmPrinter &p, SectionsOp op) {
 
   if (op.nowait())
     p << "nowait";
 
   p << ' ';
   p.printRegion(op.region());
 }
 
-static LogicalResult verifySectionsOp(SectionsOp op) {
-
+LogicalResult SectionsOp::verify() {
   // A list item may not appear in more than one clause on the same directive,
   // except that it may be specified in both firstprivate and lastprivate
   // clauses.
-  for (auto var : op.private_vars()) {
-    if (llvm::is_contained(op.firstprivate_vars(), var))
-      return op.emitOpError()
+  for (auto var : private_vars()) {
+    if (llvm::is_contained(firstprivate_vars(), var))
+      return emitOpError()
              << "operand used in both private and firstprivate clauses";
-    if (llvm::is_contained(op.lastprivate_vars(), var))
-      return op.emitOpError()
+    if (llvm::is_contained(lastprivate_vars(), var))
+      return emitOpError()
              << "operand used in both private and lastprivate clauses";
   }
 
-  if (op.allocate_vars().size() != op.allocators_vars().size())
-    return op.emitError(
+  if (allocate_vars().size() != allocators_vars().size())
+    return emitError(
         "expected equal sizes for allocate and allocator variables");
 
-  for (auto &inst : *op.region().begin()) {
-    if (!(isa<SectionOp>(inst) || isa<TerminatorOp>(inst)))
-      op.emitOpError()
+  for (auto &inst : *region().begin()) {
+    if (!(isa<SectionOp>(inst) || isa<TerminatorOp>(inst))) {
+      return emitOpError()
              << "expected omp.section op or terminator op inside region";
     }
+  }
 
-  return verifyReductionVarList(op, op.reductions(), op.reduction_vars());
+  return verifyReductionVarList(*this, reductions(), reduction_vars());
 }
 
 /// Parses an OpenMP Workshare Loop operation
 ///
 /// wsloop ::= `omp.wsloop` loop-control clause-list
 /// loop-control ::= `(` ssa-id-list `)` `:` type `=`  loop-bounds
 /// loop-bounds := `(` ssa-id-list `)` to `(` ssa-id-list `)` inclusive? steps
 /// steps := `step` `(`ssa-id-list`)`

 static void printAtomicReductionRegion(OpAsmPrinter &printer,
                                        ReductionDeclareOp op, Region &region) {
   if (region.empty())
     return;
   printer << "atomic ";
   printer.printRegion(region);
 }
 
-static LogicalResult verifyReductionDeclareOp(ReductionDeclareOp op) {
-  if (op.initializerRegion().empty())
-    return op.emitOpError() << "expects non-empty initializer region";
-  Block &initializerEntryBlock = op.initializerRegion().front();
+LogicalResult ReductionDeclareOp::verify() {
+  if (initializerRegion().empty())
+    return emitOpError() << "expects non-empty initializer region";
+  Block &initializerEntryBlock = initializerRegion().front();
   if (initializerEntryBlock.getNumArguments() != 1 ||
-      initializerEntryBlock.getArgument(0).getType() != op.type()) {
-    return op.emitOpError() << "expects initializer region with one argument "
-                               "of the reduction type";
+      initializerEntryBlock.getArgument(0).getType() != type()) {
+    return emitOpError() << "expects initializer region with one argument "
   }
 
-  for (YieldOp yieldOp : op.initializerRegion().getOps<YieldOp>()) {
+  for (YieldOp yieldOp : initializerRegion().getOps<YieldOp>()) {
     if (yieldOp.results().size() != 1 ||
-        yieldOp.results().getTypes()[0] != op.type())
-      return op.emitOpError() << "expects initializer region to yield a value "
-                                 "of the reduction type";
+        yieldOp.results().getTypes()[0] != type())
+      return emitOpError() << "expects initializer region to yield a value "
   }
 
-  if (op.reductionRegion().empty())
-    return op.emitOpError() << "expects non-empty reduction region";
-  Block &reductionEntryBlock = op.reductionRegion().front();
+  if (reductionRegion().empty())
+    return emitOpError() << "expects non-empty reduction region";
+  Block &reductionEntryBlock = reductionRegion().front();
   if (reductionEntryBlock.getNumArguments() != 2 ||
       reductionEntryBlock.getArgumentTypes()[0] !=
           reductionEntryBlock.getArgumentTypes()[1] ||
-      reductionEntryBlock.getArgumentTypes()[0] != op.type())
-    return op.emitOpError() << "expects reduction region with two arguments of "
-                               "the reduction type";
-  for (YieldOp yieldOp : op.reductionRegion().getOps<YieldOp>()) {
+      reductionEntryBlock.getArgumentTypes()[0] != type())
+    return emitOpError() << "expects reduction region with two arguments of "
+  for (YieldOp yieldOp : reductionRegion().getOps<YieldOp>()) {
     if (yieldOp.results().size() != 1 ||
-        yieldOp.results().getTypes()[0] != op.type())
-      return op.emitOpError() << "expects reduction region to yield a value "
-                                 "of the reduction type";
+        yieldOp.results().getTypes()[0] != type())
+      return emitOpError() << "expects reduction region to yield a value "
   }
 
-  if (op.atomicReductionRegion().empty())
+  if (atomicReductionRegion().empty())
     return success();
 
-  Block &atomicReductionEntryBlock = op.atomicReductionRegion().front();
+  Block &atomicReductionEntryBlock = atomicReductionRegion().front();
   if (atomicReductionEntryBlock.getNumArguments() != 2 ||
       atomicReductionEntryBlock.getArgumentTypes()[0] !=
           atomicReductionEntryBlock.getArgumentTypes()[1])
-    return op.emitOpError() << "expects atomic reduction region with two "
-                               "arguments of the same type";
+    return emitOpError() << "expects atomic reduction region with two "
   auto ptrType = atomicReductionEntryBlock.getArgumentTypes()[0]
                      .dyn_cast<PointerLikeType>();
-  if (!ptrType || ptrType.getElementType() != op.type())
-    return op.emitOpError() << "expects atomic reduction region arguments to "
-                               "be accumulators containing the reduction type";
+  if (!ptrType || ptrType.getElementType() != type())
+    return emitOpError() << "expects atomic reduction region arguments to "
   return success();
 }
 
-static LogicalResult verifyReductionOp(ReductionOp op) {
+LogicalResult ReductionOp::verify() {
   // TODO: generalize this to an op interface when there is more than one op
   // that supports reductions.
-  auto container = op->getParentOfType<WsLoopOp>();
+  auto container = (*this)->getParentOfType<WsLoopOp>();
   for (unsigned i = 0, e = container.getNumReductionVars(); i < e; ++i)
-    if (container.reduction_vars()[i] == op.accumulator())
+    if (container.reduction_vars()[i] == accumulator())
       return success();
 
-  return op.emitOpError() << "the accumulator is not used by the parent";
+  return emitOpError() << "the accumulator is not used by the parent";
 }
 
 //===----------------------------------------------------------------------===//
 // WsLoopOp
 //===----------------------------------------------------------------------===//
 
 void WsLoopOp::build(OpBuilder &builder, OperationState &state,
                      ValueRange lowerBound, ValueRange upperBound,
if (buildBody) {
     OpBuilder::InsertionGuard guard(builder);
     unsigned numIVs = steps.size();
     SmallVector<Type, 8> argTypes(numIVs, steps.getType().front());
     SmallVector<Location, 8> argLocs(numIVs, result.location);
     builder.createBlock(bodyRegion, {}, argTypes, argLocs);
   }
 }
 
-static LogicalResult verifyWsLoopOp(WsLoopOp op) {
-  return verifyReductionVarList(op, op.reductions(), op.reduction_vars());
+LogicalResult WsLoopOp::verify() {
+  return verifyReductionVarList(*this, reductions(), reduction_vars());
 }
 
 //===----------------------------------------------------------------------===//
 // Verifier for critical construct (2.17.1)
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verifyCriticalDeclareOp(CriticalDeclareOp op) {
-  return verifySynchronizationHint(op, op.hint());
+LogicalResult CriticalDeclareOp::verify() {
+  return verifySynchronizationHint(*this, hint());
 }
 
-static LogicalResult verifyCriticalOp(CriticalOp op) {
-
-  if (op.nameAttr()) {
-    auto symbolRef = op.nameAttr().cast<SymbolRefAttr>();
-    auto decl =
-        SymbolTable::lookupNearestSymbolFrom<CriticalDeclareOp>(op, symbolRef);
+LogicalResult CriticalOp::verify() {
+  if (nameAttr()) {
+    SymbolRefAttr symbolRef = nameAttr();
+    auto decl = SymbolTable::lookupNearestSymbolFrom<CriticalDeclareOp>(
+        *this, symbolRef);
     if (!decl) {
-      return op.emitOpError() << "expected symbol reference " << symbolRef
-                              << " to point to a critical declaration";
+      return emitOpError() << "expected symbol reference " << symbolRef
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Verifier for ordered construct
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verifyOrderedOp(OrderedOp op) {
-  auto container = op->getParentOfType<WsLoopOp>();
+LogicalResult OrderedOp::verify() {
+  auto container = (*this)->getParentOfType<WsLoopOp>();
   if (!container || !container.ordered_valAttr() ||
       container.ordered_valAttr().getInt() == 0)
-    return op.emitOpError() << "ordered depend directive must be closely "
-                            << "nested inside a worksharing-loop with ordered "
-                            << "clause with parameter present";
+    return emitOpError() << "ordered depend directive must be closely "
 
   if (container.ordered_valAttr().getInt() !=
-      (int64_t)op.num_loops_val().getValue())
-    return op.emitOpError() << "number of variables in depend clause does not "
-                            << "match number of iteration variables in the "
-                            << "doacross loop";
+      (int64_t)num_loops_val().getValue())
+    return emitOpError() << "number of variables in depend clause does not "
 
   return success();
 }
 
-static LogicalResult verifyOrderedRegionOp(OrderedRegionOp op) {
+LogicalResult OrderedRegionOp::verify() {
   // TODO: The code generation for ordered simd directive is not supported yet.
-  if (op.simd())
+  if (simd())
     return failure();
 
-  if (auto container = op->getParentOfType<WsLoopOp>()) {
+  if (auto container = (*this)->getParentOfType<WsLoopOp>()) {
     if (!container.ordered_valAttr() ||
         container.ordered_valAttr().getInt() != 0)
-      return op.emitOpError() << "ordered region must be closely nested inside "
-                              << "a worksharing-loop region with an ordered "
-                              << "clause without parameter present";
+      return emitOpError() << "ordered region must be closely nested inside "
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicReadOp
 //===----------------------------------------------------------------------===//
static void printAtomicReadOp(OpAsmPrinter &p, AtomicReadOp op) {
   if (auto mo = op.memory_order())
     p << "memory_order(" << stringifyClauseMemoryOrderKind(*mo) << ") ";
   if (op.hintAttr())
     printSynchronizationHint(p << " ", op, op.hintAttr());
   p << ": " << op.x().getType();
 }
 
 /// Verifier for AtomicReadOp
-static LogicalResult verifyAtomicReadOp(AtomicReadOp op) {
-  if (auto mo = op.memory_order()) {
+LogicalResult AtomicReadOp::verify() {
+  if (auto mo = memory_order()) {
     if (*mo == ClauseMemoryOrderKind::acq_rel ||
         *mo == ClauseMemoryOrderKind::release) {
-      return op.emitError(
+      return emitError(
           "memory-order must not be acq_rel or release for atomic reads");
     }
   }
-  if (op.x() == op.v())
-    return op.emitError(
+  if (x() == v())
+    return emitError(
         "read and write must not be to the same location for atomic reads");
-  return verifySynchronizationHint(op, op.hint());
+  return verifySynchronizationHint(*this, hint());
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicWriteOp
 //===----------------------------------------------------------------------===//
 
 /// Parser for AtomicWriteOp
 ///
static void printAtomicWriteOp(OpAsmPrinter &p, AtomicWriteOp op) {
   if (auto mo = op.memory_order())
     p << "memory_order(" << stringifyClauseMemoryOrderKind(*mo) << ") ";
   if (op.hintAttr())
     printSynchronizationHint(p, op, op.hintAttr());
   p << ": " << op.address().getType() << ", " << op.value().getType();
 }
 
 /// Verifier for AtomicWriteOp
-static LogicalResult verifyAtomicWriteOp(AtomicWriteOp op) {
-  if (auto mo = op.memory_order()) {
+LogicalResult AtomicWriteOp::verify() {
+  if (auto mo = memory_order()) {
     if (*mo == ClauseMemoryOrderKind::acq_rel ||
         *mo == ClauseMemoryOrderKind::acquire) {
-      return op.emitError(
+      return emitError(
           "memory-order must not be acq_rel or acquire for atomic writes");
     }
   }
-  return verifySynchronizationHint(op, op.hint());
+  return verifySynchronizationHint(*this, hint());
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicUpdateOp
 //===----------------------------------------------------------------------===//
 
 /// Parser for AtomicUpdateOp
 ///
static void printAtomicUpdateOp(OpAsmPrinter &p, AtomicUpdateOp op) {
   if (auto mo = op.memory_order())
     p << "memory_order(" << stringifyClauseMemoryOrderKind(*mo) << ") ";
   if (op.hintAttr())
     printSynchronizationHint(p, op, op.hintAttr());
   p << ": " << op.x().getType() << ", " << op.expr().getType();
 }
 
 /// Verifier for AtomicUpdateOp
-static LogicalResult verifyAtomicUpdateOp(AtomicUpdateOp op) {
-  if (auto mo = op.memory_order()) {
+LogicalResult AtomicUpdateOp::verify() {
+  if (auto mo = memory_order()) {
     if (*mo == ClauseMemoryOrderKind::acq_rel ||
         *mo == ClauseMemoryOrderKind::acquire) {
-      return op.emitError(
+      return emitError(
           "memory-order must not be acq_rel or acquire for atomic updates");
     }
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicCaptureOp
static void printAtomicCaptureOp(OpAsmPrinter &p, AtomicCaptureOp op) {
   if (op.memory_order())
     p << "memory_order(" << op.memory_order() << ") ";
   if (op.hintAttr())
     printSynchronizationHint(p, op, op.hintAttr());
   p.printRegion(op.region());
 }
 
 /// Verifier for AtomicCaptureOp
-static LogicalResult verifyAtomicCaptureOp(AtomicCaptureOp op) {
-  Block::OpListType &ops = op.region().front().getOperations();
+LogicalResult AtomicCaptureOp::verify() {
+  Block::OpListType &ops = region().front().getOperations();
   if (ops.size() != 3)
-    return emitError(op.getLoc())
+    return emitError()
            << "expected three operations in omp.atomic.capture region (one "
               "terminator, and two atomic ops)";
   auto &firstOp = ops.front();
   auto &secondOp = *ops.getNextNode(firstOp);
   auto firstReadStmt = dyn_cast<AtomicReadOp>(firstOp);
   auto firstUpdateStmt = dyn_cast<AtomicUpdateOp>(firstOp);
   auto secondReadStmt = dyn_cast<AtomicReadOp>(secondOp);
   auto secondUpdateStmt = dyn_cast<AtomicUpdateOp>(secondOp);
   auto secondWriteStmt = dyn_cast<AtomicWriteOp>(secondOp);
 
   if (!((firstUpdateStmt && secondReadStmt) ||
         (firstReadStmt && secondUpdateStmt) ||
         (firstReadStmt && secondWriteStmt)))
-    return emitError(ops.front().getLoc())
+    return ops.front().emitError()
            << "invalid sequence of operations in the capture region";
   if (firstUpdateStmt && secondReadStmt &&
       firstUpdateStmt.x() != secondReadStmt.x())
-    return emitError(firstUpdateStmt.getLoc())
+    return firstUpdateStmt.emitError()
            << "updated variable in omp.atomic.update must be captured in "
               "second operation";
   if (firstReadStmt && secondUpdateStmt &&
       firstReadStmt.x() != secondUpdateStmt.x())
-    return emitError(firstReadStmt.getLoc())
+    return firstReadStmt.emitError()
            << "captured variable in omp.atomic.read must be updated in second "
               "operation";
   if (firstReadStmt && secondWriteStmt &&
       firstReadStmt.x() != secondWriteStmt.address())
-    return emitError(firstReadStmt.getLoc())
+    return firstReadStmt.emitError()
            << "captured variable in omp.atomic.read must be updated in "
               "second operation";
   return success();
 }
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOpsAttributes.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"

mlir/test/Dialect/OpenACC/invalid.mlir

 %value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
 acc.update wait_devnum(%cst: index) host(%value: memref<10xf32>)
 
 // -----
 
 %cst = arith.constant 1 : index
 %value = memref.alloc() : memref<10xf32>
-// expected-error@+1 {{async attribute cannot appear with  asyncOperand}}
+// expected-error@+1 {{async attribute cannot appear with asyncOperand}}
 acc.update async(%cst: index) host(%value: memref<10xf32>) attributes {async}
 
 // -----
 
 %cst = arith.constant 1 : index
 %value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait attribute cannot appear with waitOperands}}
 acc.update wait(%cst: index) host(%value: memref<10xf32>) attributes {wait}