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

[rriddle]

Summary

The verifier field is deprecated, and slated for removal.

Depends on D118827

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

 //===----------------------------------------------------------------------===//
 // PDL Ops
 //===----------------------------------------------------------------------===//
 
 class PDL_Op<string mnemonic, list<Trait> traits = []>
     : Op<PDL_Dialect, mnemonic, traits> {
   let printer = [{ ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
-  let verifier = [{ return ::verify(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ApplyNativeConstraintOp
     : PDL_Op<"apply_native_constraint", [HasParent<"pdl::PatternOp">]> {
def PDL_ApplyNativeConstraintOp
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
                    CArg<"ArrayRef<Attribute>", "{}">:$params), [{
       build($_builder, $_state, $_builder.getStringAttr(name), args,
             params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
     }]>,
   ];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ApplyNativeRewriteOp
     : PDL_Op<"apply_native_rewrite", [HasParent<"pdl::RewriteOp">]> {
def PDL_ApplyNativeRewriteOp
   let arguments = (ins StrAttr:$name,
                        Variadic<PDL_AnyType>:$args,
                        OptionalAttr<ArrayAttr>:$constParams);
   let results = (outs Variadic<PDL_AnyType>:$results);
   let assemblyFormat = [{
     $name ($constParams^)? (`(` $args^ `:` type($args) `)`)?
     (`:` type($results)^)? attr-dict
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDL_AttributeOp : PDL_Op<"attribute", [NoSideEffect]> {
   let summary = "Define an input attribute in a pattern";
let builders = [
     OpBuilder<(ins CArg<"Value", "Value()">:$type), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), type,
             Attribute());
     }]>,
     OpBuilder<(ins "Attribute":$attr), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), Value(), attr);
     }]>,
   ];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::EraseOp
 //===----------------------------------------------------------------------===//
 
 def PDL_EraseOp : PDL_Op<"erase", [HasParent<"pdl::RewriteOp">]> {
   let summary = "Mark an input operation as `erased`";
   let description = [{
     `pdl.erase` operations are used within `pdl.rewrite` regions to specify that
     an input operation should be marked as erased. The semantics of this
     operation correspond with the `eraseOp` method on a `PatternRewriter`.
 
     Example:
 
     ```mlir
     pdl.erase %root
     ```
   }];
   let arguments = (ins PDL_Operation:$operation);
   let assemblyFormat = "$operation attr-dict";
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandOp
     : PDL_Op<"operand", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
def PDL_OperandOp
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "(`:` $type^)? attr-dict";
 
   let builders = [
     OpBuilder<(ins), [{
       build($_builder, $_state, $_builder.getType<ValueType>(), Value());
     }]>,
   ];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandsOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandsOp
     : PDL_Op<"operands", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
def PDL_OperandsOp
   let assemblyFormat = "(`:` $type^)? attr-dict";
 
   let builders = [
     OpBuilder<(ins), [{
       build($_builder, $_state, RangeType::get($_builder.getType<ValueType>()),
             Value());
     }]>,
   ];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperationOp : PDL_Op<"operation", [AttrSizedOperandSegments]> {
   let summary = "Define an operation within a pattern";
OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
             resultTypes);
     }]>,
   ];
   let extraClassDeclaration = [{
     /// Returns true if the operation type referenced supports result type
     /// inference.
     bool hasTypeInference();
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 def PDL_PatternOp : PDL_Op<"pattern", [
     IsolatedFromAbove, SingleBlock, Symbol,
let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
 
     /// A PatternOp may optionally define a symbol.
     bool isOptionalSymbol() { return true; }
 
     /// Returns the rewrite operation of this pattern.
     RewriteOp getRewriter();
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ReplaceOp : PDL_Op<"replace", [
     AttrSizedOperandSegments, HasParent<"pdl::RewriteOp">
def PDL_ReplaceOp : PDL_Op<"replace", [
   }];
   let arguments = (ins PDL_Operation:$operation,
                        Optional<PDL_Operation>:$replOperation,
                        Variadic<PDL_InstOrRangeOf<PDL_Value>>:$replValues);
   let assemblyFormat = [{
     $operation `with` (`(` $replValues^ `:` type($replValues) `)`)?
     ($replOperation^)? attr-dict
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ResultOp : PDL_Op<"result", [NoSideEffect]> {
   let summary = "Extract a result from an operation";
let description = [{
     // If the example pattern snippet above were matching against `foo.op` in
     // the IR snippet, `%pdl_result` would correspond to `%result_1`.
     ```
   }];
 
   let arguments = (ins PDL_Operation:$parent, I32Attr:$index);
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "$index `of` $parent attr-dict";
-  let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultsOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ResultsOp : PDL_Op<"results", [NoSideEffect]> {
   let summary = "Extract a result group from an operation";
def PDL_ResultsOp : PDL_Op<"results", [NoSideEffect]> {
   }];
 
   let arguments = (ins PDL_Operation:$parent, OptionalAttr<I32Attr>:$index);
   let results = (outs PDL_InstOrRangeOf<PDL_Value>:$val);
   let assemblyFormat = [{
     ($index^)? `of` $parent custom<ResultsValueType>(ref($index), type($val))
     attr-dict
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_RewriteOp : PDL_Op<"rewrite", [
      Terminator, HasParent<"pdl::PatternOp">, NoTerminator, NoRegionArguments,
let arguments = (ins Optional<PDL_Operation>:$root,
                        OptionalAttr<ArrayAttr>:$externalConstParams);
   let regions = (region AnyRegion:$body);
   let assemblyFormat = [{
     ($root^)? (`with` $name^ ($externalConstParams^)?
                              (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
               ($body^)?
     attr-dict-with-keyword
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 def PDL_TypeOp : PDL_Op<"type", [NoSideEffect]> {
   let summary = "Define a type handle within a pattern";
let description = [{
     // Define a type with a constant value:
     %type = pdl.type : i32
     ```
   }];
 
   let arguments = (ins OptionalAttr<TypeAttr>:$type);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "attr-dict (`:` $type^)?";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
 def PDL_TypesOp : PDL_Op<"types", [NoSideEffect]> {
   let summary = "Define a range of type handles within a pattern";
let description = [{
     // Define a range of types with a range of constant values:
     %types = pdl.types : [i32, i64, i32]
     ```
   }];
 
   let arguments = (ins OptionalAttr<TypeArrayAttr>:$types);
   let results = (outs PDL_RangeOf<PDL_Type>:$result);
   let assemblyFormat = "attr-dict (`:` $types^)?";
+  let hasVerifier = 1;
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLOPS

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

 // PDLInterp_SwitchOp
 
 // Switch operations evaluate a predicate on a positional value and then
 // conditionally branch on the result.
 class PDLInterp_SwitchOp<string mnemonic, list<Trait> traits = []> :
     PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
   let successors = (successor AnySuccessor:$defaultDest,
                               VariadicSuccessor<AnySuccessor>:$cases);
-
-  let verifier = [{
-    // Verify that the number of case destinations matches the number of case
-    // values.
-    size_t numDests = cases().size();
-    size_t numValues = caseValues().size();
-    if (numDests != numValues) {
-      return emitOpError("expected number of cases to match the number of case "
-                         "values, got ")
-          << numDests << " but expected " << numValues;
-    }
-    return success();
-  }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ApplyConstraintOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_ApplyConstraintOp : PDLInterp_PredicateOp<"apply_constraint"> {
   let summary = "Apply a constraint to a set of positional values";
def PDLInterp_ForEachOp
   ];
 
   let extraClassDeclaration = [{
     /// Returns the loop variable.
     BlockArgument getLoopVariable() { return region().getArgument(0); }
   }];
   let parser = [{ return ::parseForEachOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
-  let verifier = [{ return ::verify(*this); }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetAttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
   let summary = "Get a specified attribute value from an `Operation`";
def PDLInterp_SwitchAttributeOp
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$attribute, "ArrayRef<Attribute>":$caseValues,
       "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, attribute, $_builder.getArrayAttr(caseValues),
           defaultDest, dests);
   }]>];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchOperandCountOp
     : PDLInterp_SwitchOp<"switch_operand_count", [NoSideEffect]> {
def PDLInterp_SwitchOperandCountOp
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
                    "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperationNameOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchOperationNameOp
     : PDLInterp_SwitchOp<"switch_operation_name", [NoSideEffect]> {
let builders = [
     OpBuilder<(ins "Value":$operation, "ArrayRef<OperationName>":$names,
       "Block *":$defaultDest, "BlockRange":$dests), [{
       auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
           [](OperationName name) { return name.getStringRef(); }));
       build($_builder, $_state, operation, $_builder.getStrArrayAttr(stringNames),
             defaultDest, dests);
     }]>,
   ];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchResultCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchResultCountOp
     : PDLInterp_SwitchOp<"switch_result_count", [NoSideEffect]> {
def PDLInterp_SwitchResultCountOp
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
                    "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
   let summary = "Switch on a `Type` value";
OpBuilder<(ins "Value":$edge, "ArrayRef<Attribute>":$types,
       build($_builder, $_state, edge, $_builder.getArrayAttr(types),
             defaultDest, dests);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
   }];
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypesOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchTypesOp : PDLInterp_SwitchOp<"switch_types",
                                                  [NoSideEffect]> {
OpBuilder<(ins "Value":$edge, "ArrayRef<Attribute>":$types,
       build($_builder, $_state, edge, $_builder.getArrayAttr(types),
             defaultDest, dests);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     auto getCaseTypes() { return caseValues().getAsRange<ArrayAttr>(); }
   }];
+  let hasVerifier = 1;
 }
 
 #endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS

mlir/lib/Dialect/PDL/IR/PDL.cpp

static void visit(Operation *op, DenseSet<Operation *> &visited) {
   for (Operation *user : op->getUsers())
     visit(user, visited);
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ApplyNativeConstraintOp op) {
-  if (op.getNumOperands() == 0)
-    return op.emitOpError("expected at least one argument");
+LogicalResult ApplyNativeConstraintOp::verify() {
+  if (getNumOperands() == 0)
+    return emitOpError("expected at least one argument");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ApplyNativeRewriteOp op) {
-  if (op.getNumOperands() == 0 && op.getNumResults() == 0)
-    return op.emitOpError("expected at least one argument or result");
+LogicalResult ApplyNativeRewriteOp::verify() {
+  if (getNumOperands() == 0 && getNumResults() == 0)
+    return emitOpError("expected at least one argument or result");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(AttributeOp op) {
-  Value attrType = op.type();
-  Optional<Attribute> attrValue = op.value();
+LogicalResult AttributeOp::verify() {
+  Value attrType = type();
+  Optional<Attribute> attrValue = value();
 
   if (!attrValue) {
-    if (isa<RewriteOp>(op->getParentOp()))
-      return op.emitOpError("expected constant value when specified within a "
-                            "`pdl.rewrite`");
-    return verifyHasBindingUse(op);
+    if (isa<RewriteOp>((*this)->getParentOp()))
+      return emitOpError(
+          "expected constant value when specified within a `pdl.rewrite`");
+    return verifyHasBindingUse(*this);
   }
   if (attrType)
-    return op.emitOpError("expected only one of [`type`, `value`] to be set");
+    return emitOpError("expected only one of [`type`, `value`] to be set");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(OperandOp op) { return verifyHasBindingUse(op); }
+LogicalResult OperandOp::verify() { return verifyHasBindingUse(*this); }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandsOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(OperandsOp op) { return verifyHasBindingUse(op); }
+LogicalResult OperandsOp::verify() { return verifyHasBindingUse(*this); }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseOperationOpAttributes(
     OpAsmParser &p, SmallVectorImpl<OpAsmParser::OperandType> &attrOperands,
     ArrayAttr &attrNamesAttr) {
return op
         .emitOpError("must have inferable or constrained result types when "
                      "nested within `pdl.rewrite`")
         .attachNote()
         .append("result type #", it.index(), " was not constrained");
   }
   return success();
 }
 
-static LogicalResult verify(OperationOp op) {
-  bool isWithinRewrite = isa<RewriteOp>(op->getParentOp());
-  if (isWithinRewrite && !op.name())
-    return op.emitOpError("must have an operation name when nested within "
-                          "a `pdl.rewrite`");
-  ArrayAttr attributeNames = op.attributeNames();
-  auto attributeValues = op.attributes();
+LogicalResult OperationOp::verify() {
+  bool isWithinRewrite = isa<RewriteOp>((*this)->getParentOp());
+  if (isWithinRewrite && !name())
+    return emitOpError("must have an operation name when nested within "
+  ArrayAttr attributeNames = attributeNamesAttr();
+  auto attributeValues = attributes();
   if (attributeNames.size() != attributeValues.size()) {
-    return op.emitOpError()
+    return emitOpError()
            << "expected the same number of attribute values and attribute "
               "names, got "
            << attributeNames.size() << " names and " << attributeValues.size()
            << " values";
   }
 
   // If the operation is within a rewrite body and doesn't have type inference,
   // ensure that the result types can be resolved.
-  if (isWithinRewrite && !op.hasTypeInference()) {
-    if (failed(verifyResultTypesAreInferrable(op, op.types())))
+  if (isWithinRewrite && !hasTypeInference()) {
+    if (failed(verifyResultTypesAreInferrable(*this, types())))
       return failure();
   }
 
-  return verifyHasBindingUse(op);
+  return verifyHasBindingUse(*this);
 }
 
 bool OperationOp::hasTypeInference() {
   Optional<StringRef> opName = name();
   if (!opName)
     return false;
 
   if (auto rInfo = RegisteredOperationName::lookup(*opName, getContext()))
     return rInfo->hasInterface<InferTypeOpInterface>();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(PatternOp pattern) {
-  Region &body = pattern.body();
+LogicalResult PatternOp::verify() {
+  Region &body = getBodyRegion();
   Operation *term = body.front().getTerminator();
   auto rewriteOp = dyn_cast<RewriteOp>(term);
   if (!rewriteOp) {
-    return pattern.emitOpError("expected body to terminate with `pdl.rewrite`")
+    return emitOpError("expected body to terminate with `pdl.rewrite`")
         .attachNote(term->getLoc())
         .append("see terminator defined here");
   }
 
   // Check that all values defined in the top-level pattern belong to the PDL
   // dialect.
   WalkResult result = body.walk([&](Operation *op) -> WalkResult {
     if (!isa_and_nonnull<PDLDialect>(op->getDialect())) {
-      pattern
-          .emitOpError("expected only `pdl` operations within the pattern body")
+      emitOpError("expected only `pdl` operations within the pattern body")
           .attachNote(op->getLoc())
           .append("see non-`pdl` operation defined here");
       return WalkResult::interrupt();
     }
     return WalkResult::advance();
   });
   if (result.wasInterrupted())
     return failure();
 
   // Check that there is at least one operation.
   if (body.front().getOps<OperationOp>().empty())
-    return pattern.emitOpError(
-        "the pattern must contain at least one `pdl.operation`");
+    return emitOpError("the pattern must contain at least one `pdl.operation`");
 
   // Determine if the operations within the pdl.pattern form a connected
   // component. This is determined by starting the search from the first
   // operand/result/operation and visiting their users / parents / operands.
   // We limit our attention to operations that have a user in pdl.rewrite,
   // those that do not will be detected via other means (expected bindable
   // user).
   bool first = true;
if (!hasUserInRewrite)
       continue;
 
     if (first) {
       // For the first operation, invoke visit.
       visit(&op, visited);
       first = false;
     } else if (!visited.count(&op)) {
       // For the subsequent operations, check if already visited.
-      return pattern
-          .emitOpError("the operations must form a connected component")
+      return emitOpError("the operations must form a connected component")
           .attachNote(op.getLoc())
           .append("see a disconnected value / operation here");
     }
   }
 
   return success();
 }
 

 StringRef PatternOp::getDefaultDialect() {
   return PDLDialect::getDialectNamespace();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ReplaceOp op) {
-  if (op.replOperation() && !op.replValues().empty())
-    return op.emitOpError() << "expected no replacement values to be provided"
-                               " when the replacement operation is present";
+LogicalResult ReplaceOp::verify() {
+  if (replOperation() && !replValues().empty())
+    return emitOpError() << "expected no replacement values to be provided"
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultsOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseResultsValueType(OpAsmParser &p, IntegerAttr index,
                                          Type &resultType) {
   if (!index) {
     resultType = RangeType::get(p.getBuilder().getType<ValueType>());
     return success();
   }
   if (p.parseArrow() || p.parseType(resultType))
     return failure();
   return success();
 }
 
 static void printResultsValueType(OpAsmPrinter &p, ResultsOp op,
                                   IntegerAttr index, Type resultType) {
   if (index)
     p << " -> " << resultType;
 }
 
-static LogicalResult verify(ResultsOp op) {
-  if (!op.index() && op.getType().isa<pdl::ValueType>()) {
-    return op.emitOpError() << "expected `pdl.range<value>` result type when "
-                               "no index is specified, but got: "
-                            << op.getType();
+LogicalResult ResultsOp::verify() {
+  if (!index() && getType().isa<pdl::ValueType>()) {
+    return emitOpError() << "expected `pdl.range<value>` result type when "
+                         << getType();
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(RewriteOp op) {
-  Region &rewriteRegion = op.body();
+LogicalResult RewriteOp::verify() {
+  Region &rewriteRegion = body();
 
   // Handle the case where the rewrite is external.
-  if (op.name()) {
+  if (name()) {
     if (!rewriteRegion.empty()) {
-      return op.emitOpError()
+      return emitOpError()
              << "expected rewrite region to be empty when rewrite is external";
     }
     return success();
   }
 
   // Otherwise, check that the rewrite region only contains a single block.
   if (rewriteRegion.empty()) {
-    return op.emitOpError() << "expected rewrite region to be non-empty if "
-                               "external name is not specified";
+    return emitOpError() << "expected rewrite region to be non-empty if "
   }
 
   // Check that no additional arguments were provided.
-  if (!op.externalArgs().empty()) {
-    return op.emitOpError() << "expected no external arguments when the "
-                               "rewrite is specified inline";
+  if (!externalArgs().empty()) {
+    return emitOpError() << "expected no external arguments when the "
   }
-  if (op.externalConstParams()) {
-    return op.emitOpError() << "expected no external constant parameters when "
-                               "the rewrite is specified inline";
+  if (externalConstParams()) {
+    return emitOpError() << "expected no external constant parameters when "
   }
 
   return success();
 }
 
 /// The default dialect is `pdl`.
 StringRef RewriteOp::getDefaultDialect() {
   return PDLDialect::getDialectNamespace();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(TypeOp op) {
-  if (!op.typeAttr())
-    return verifyHasBindingUse(op);
+LogicalResult TypeOp::verify() {
+  if (!typeAttr())
+    return verifyHasBindingUse(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(TypesOp op) {
-  if (!op.typesAttr())
-    return verifyHasBindingUse(op);
+LogicalResult TypesOp::verify() {
+  if (!typesAttr())
+    return verifyHasBindingUse(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 
 void PDLInterpDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"
       >();
 }
 
+template <typename OpT>
+static LogicalResult verifySwitchOp(OpT op) {
+  // Verify that the number of case destinations matches the number of case
+  // values.
+  size_t numDests = op.cases().size();
+  size_t numValues = op.caseValues().size();
+  if (numDests != numValues) {
+    return op.emitOpError(
+               "expected number of cases to match the number of case "
+               "values, got ")
+           << numDests << " but expected " << numValues;
+  }
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateOperationOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseCreateOperationOpAttributes(
     OpAsmParser &p, SmallVectorImpl<OpAsmParser::OperandType> &attrOperands,
     ArrayAttr &attrNamesAttr) {
   Builder &builder = p.getBuilder();
static void print(OpAsmPrinter &p, ForEachOp op) {
   BlockArgument arg = op.getLoopVariable();
   p << ' ' << arg << " : " << arg.getType() << " in " << op.values() << ' ';
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
   p.printOptionalAttrDict(op->getAttrs());
   p << " -> ";
   p.printSuccessor(op.successor());
 }
 
-static LogicalResult verify(ForEachOp op) {
+LogicalResult ForEachOp::verify() {
   // Verify that the operation has exactly one argument.
-  if (op.region().getNumArguments() != 1)
-    return op.emitOpError("requires exactly one argument");
+  if (region().getNumArguments() != 1)
+    return emitOpError("requires exactly one argument");
 
   // Verify that the loop variable and the operand (value range)
   // have compatible types.
-  BlockArgument arg = op.getLoopVariable();
+  BlockArgument arg = getLoopVariable();
   Type rangeType = pdl::RangeType::get(arg.getType());
-  if (rangeType != op.values().getType())
-    return op.emitOpError("operand must be a range of loop variable type");
+  if (rangeType != values().getType())
+    return emitOpError("operand must be a range of loop variable type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetValueTypeOp
 //===----------------------------------------------------------------------===//
 
 /// Given the result type of a `GetValueTypeOp`, return the expected input type.
 static Type getGetValueTypeOpValueType(Type type) {
   Type valueTy = pdl::ValueType::get(type.getContext());
   return type.isa<pdl::RangeType>() ? pdl::RangeType::get(valueTy) : valueTy;
 }
 
 //===----------------------------------------------------------------------===//
+// pdl_interp::SwitchAttributeOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchAttributeOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperandCountOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchOperandCountOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperationNameOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchOperationNameOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchResultCountOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchResultCountOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchTypeOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchTypeOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchTypesOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult SwitchTypesOp::verify() { return verifySwitchOp(*this); }
+
+//===----------------------------------------------------------------------===//
 // TableGen Auto-Generated Op and Interface Definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"