[mlir:PDLInterp][NFC] Switch to using prefixed accessors

PDLInterp is effectively an internal dialect, so there isn't a need to
stage the switch.

4 files changed, 143 insertions, 147 deletions

diff --git a/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td b/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
index 44ee25d..e9c7cca 100644
--- a/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
+++ b/mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
@@ -48,6 +48,7 @@ def PDLInterp_Dialect : Dialect {
     /// to rewrite the IR after a successful match.
     static StringRef getRewriterModuleName() { return "rewriters"; }
   }];
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 //===----------------------------------------------------------------------===//
@@ -246,11 +247,11 @@ def PDLInterp_CheckOperandCountOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        Confined<I32Attr, [IntNonNegative]>:$count,
                        UnitAttr:$compareAtLeast);
   let assemblyFormat = [{
-    `of` $operation `is` (`at_least` $compareAtLeast^)? $count attr-dict
+    `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
     `->` successors
   }];
 }
@@ -274,8 +275,8 @@ def PDLInterp_CheckOperationNameOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation, StrAttr:$name);
-  let assemblyFormat = "`of` $operation `is` $name attr-dict `->` successors";
+  let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
+  let assemblyFormat = "`of` $inputOp `is` $name attr-dict `->` successors";
 }
 
 //===----------------------------------------------------------------------===//
@@ -303,11 +304,11 @@ def PDLInterp_CheckResultCountOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        Confined<I32Attr, [IntNonNegative]>:$count,
                        UnitAttr:$compareAtLeast);
   let assemblyFormat = [{
-    `of` $operation `is` (`at_least` $compareAtLeast^)? $count attr-dict
+    `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
     `->` successors
   }];
 }
@@ -432,11 +433,11 @@ def PDLInterp_CreateOperationOp
   }];
 
   let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$operands,
-                       Variadic<PDL_Attribute>:$attributes,
-                       StrArrayAttr:$attributeNames,
-                       Variadic<PDL_InstOrRangeOf<PDL_Type>>:$types);
-  let results = (outs PDL_Operation:$operation);
+                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$inputOperands,
+                       Variadic<PDL_Attribute>:$inputAttributes,
+                       StrArrayAttr:$inputAttributeNames,
+                       Variadic<PDL_InstOrRangeOf<PDL_Type>>:$inputResultTypes);
+  let results = (outs PDL_Operation:$resultOp);
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "ValueRange":$types,
@@ -447,9 +448,9 @@ def PDLInterp_CreateOperationOp
     }]>
   ];
   let assemblyFormat = [{
-    $name (`(` $operands^ `:` type($operands) `)`)?
-    custom<CreateOperationOpAttributes>($attributes, $attributeNames)
-    (`->` `(` $types^ `:` type($types) `)`)? attr-dict
+    $name (`(` $inputOperands^ `:` type($inputOperands) `)`)?
+    custom<CreateOperationOpAttributes>($inputAttributes, $inputAttributeNames)
+    (`->` `(` $inputResultTypes^ `:` type($inputResultTypes) `)`)? attr-dict
   }];
 }
 
@@ -528,8 +529,8 @@ def PDLInterp_EraseOp : PDLInterp_Op<"erase"> {
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation);
-  let assemblyFormat = "$operation attr-dict";
+  let arguments = (ins PDL_Operation:$inputOp);
+  let assemblyFormat = "$inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
@@ -623,7 +624,7 @@ def PDLInterp_ForEachOp
 
   let extraClassDeclaration = [{
     /// Returns the loop variable.
-    BlockArgument getLoopVariable() { return region().getArgument(0); }
+    BlockArgument getLoopVariable() { return getRegion().getArgument(0); }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
@@ -667,21 +668,15 @@ def PDLInterp_FuncOp : PDLInterp_Op<"func", [
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
   >];
   let extraClassDeclaration = [{
-    /// Returns the type of this function.
-    /// FIXME: We should drive this via the ODS `type` param.
-    FunctionType getType() { 
-      return getTypeAttr().getValue().cast<FunctionType>();
-    }
-
     //===------------------------------------------------------------------===//
     // FunctionOpInterface Methods
     //===------------------------------------------------------------------===//
 
     /// Returns the argument types of this function.
-    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+    ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
 
     /// Returns the result types of this function.
-    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+    ArrayRef<Type> getResultTypes() { return getType().getResults(); }
   }];
   let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
@@ -705,10 +700,9 @@ def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
-                       StrAttr:$name);
+  let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
   let results = (outs PDL_Attribute:$attribute);
-  let assemblyFormat = "$name `of` $operation attr-dict";
+  let assemblyFormat = "$name `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
@@ -761,7 +755,7 @@ def PDLInterp_GetDefiningOpOp
   }];
 
   let arguments = (ins PDL_InstOrRangeOf<PDL_Value>:$value);
-  let results = (outs PDL_Operation:$operation);
+  let results = (outs PDL_Operation:$inputOp);
   let assemblyFormat = "`of` $value `:` type($value) attr-dict";
 }
 
@@ -783,10 +777,10 @@ def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        Confined<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
-  let assemblyFormat = "$index `of` $operation attr-dict";
+  let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
@@ -818,15 +812,15 @@ def PDLInterp_GetOperandsOp : PDLInterp_Op<"get_operands", [NoSideEffect]> {
   }];
 
   let arguments = (ins
-    PDL_Operation:$operation,
+    PDL_Operation:$inputOp,
     OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
   );
   let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
-  let assemblyFormat = "($index^)? `of` $operation `:` type($value) attr-dict";
+  let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
   let builders = [
-    OpBuilder<(ins "Type":$resultType, "Value":$operation,
+    OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
                    "Optional<unsigned>":$index), [{
-      build($_builder, $_state, resultType, operation,
+      build($_builder, $_state, resultType, inputOp,
             index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
     }]>,
   ];
@@ -850,10 +844,10 @@ def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        Confined<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
-  let assemblyFormat = "$index `of` $operation attr-dict";
+  let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
@@ -885,20 +879,20 @@ def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [NoSideEffect]> {
   }];
 
   let arguments = (ins
-    PDL_Operation:$operation,
+    PDL_Operation:$inputOp,
     OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
   );
   let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
-  let assemblyFormat = "($index^)? `of` $operation `:` type($value) attr-dict";
+  let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
   let builders = [
-    OpBuilder<(ins "Type":$resultType, "Value":$operation,
+    OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
                    "Optional<unsigned>":$index), [{
-      build($_builder, $_state, resultType, operation,
+      build($_builder, $_state, resultType, inputOp,
             index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
     }]>,
-    OpBuilder<(ins "Value":$operation), [{
+    OpBuilder<(ins "Value":$inputOp), [{
       build($_builder, $_state,
-            pdl::RangeType::get($_builder.getType<pdl::ValueType>()), operation,
+            pdl::RangeType::get($_builder.getType<pdl::ValueType>()), inputOp,
             IntegerAttr());
     }]>,
   ];
@@ -996,7 +990,7 @@ def PDLInterp_InferredTypesOp : PDLInterp_Op<"inferred_types"> {
     %types = pdl_interp.inferred_types
     ```
   }];
-  let results = (outs PDL_RangeOf<PDL_Type>:$type);
+  let results = (outs PDL_RangeOf<PDL_Type>:$result);
   let assemblyFormat = "attr-dict";
   let builders = [
     OpBuilder<(ins), [{
@@ -1086,10 +1080,10 @@ def PDLInterp_ReplaceOp : PDLInterp_Op<"replace"> {
     pdl_interp.replace %root with (%val0, %val1 : !pdl.type, !pdl.type)
     ```
   }];
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        Variadic<PDL_InstOrRangeOf<PDL_Value>>:$replValues);
   let assemblyFormat = [{
-    $operation `with` ` ` `(` ($replValues^ `:` type($replValues))? `)`
+    $inputOp `with` ` ` `(` ($replValues^ `:` type($replValues))? `)`
     attr-dict
   }];
 }
@@ -1147,15 +1141,15 @@ def PDLInterp_SwitchOperandCountOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let arguments = (ins PDL_Operation:$inputOp, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
-    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+    `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+    OpBuilder<(ins "Value":$inputOp, "ArrayRef<int32_t>":$counts,
                    "Block *":$defaultDest, "BlockRange":$dests), [{
-    build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
+    build($_builder, $_state, inputOp, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
   let hasVerifier = 1;
@@ -1181,18 +1175,18 @@ def PDLInterp_SwitchOperationNameOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$inputOp,
                        StrArrayAttr:$caseValues);
   let assemblyFormat = [{
-    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+    `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<(ins "Value":$operation, "ArrayRef<OperationName>":$names,
+    OpBuilder<(ins "Value":$inputOp, "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),
+      build($_builder, $_state, inputOp, $_builder.getStrArrayAttr(stringNames),
             defaultDest, dests);
     }]>,
   ];
@@ -1219,15 +1213,15 @@ def PDLInterp_SwitchResultCountOp
     ```
   }];
 
-  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let arguments = (ins PDL_Operation:$inputOp, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
-    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+    `of` $inputOp `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+    OpBuilder<(ins "Value":$inputOp, "ArrayRef<int32_t>":$counts,
                    "Block *":$defaultDest, "BlockRange":$dests), [{
-    build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
+    build($_builder, $_state, inputOp, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
   let hasVerifier = 1;
@@ -1266,7 +1260,7 @@ def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
   ];
 
   let extraClassDeclaration = [{
-    auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
+    auto getCaseTypes() { return getCaseValues().getAsValueRange<TypeAttr>(); }
   }];
   let hasVerifier = 1;
 }
@@ -1308,7 +1302,7 @@ def PDLInterp_SwitchTypesOp : PDLInterp_SwitchOp<"switch_types",
   ];
 
   let extraClassDeclaration = [{
-    auto getCaseTypes() { return caseValues().getAsRange<ArrayAttr>(); }
+    auto getCaseTypes() { return getCaseValues().getAsRange<ArrayAttr>(); }
   }];
   let hasVerifier = 1;
 }
diff --git a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
index 767f1cf..9529c59f 100644
--- a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
+++ b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp
@@ -281,11 +281,11 @@ Value PatternLowering::getValueAt(Block *&currentBlock, Position *pos) {
     value = foreach.getLoopVariable();
 
     // Create the continuation block.
-    Block *continueBlock = builder.createBlock(&foreach.region());
+    Block *continueBlock = builder.createBlock(&foreach.getRegion());
     builder.create<pdl_interp::ContinueOp>(loc);
     failureBlockStack.push_back(continueBlock);
 
-    currentBlock = &foreach.region().front();
+    currentBlock = &foreach.getRegion().front();
     break;
   }
   case Predicates::OperandPos: {
@@ -679,7 +679,7 @@ void PatternLowering::generateRewriter(
   auto interpOp = builder.create<pdl_interp::ApplyRewriteOp>(
       rewriteOp.getLoc(), rewriteOp.getResultTypes(), rewriteOp.nameAttr(),
       arguments, rewriteOp.constParamsAttr());
-  for (auto it : llvm::zip(rewriteOp.results(), interpOp.results()))
+  for (auto it : llvm::zip(rewriteOp.results(), interpOp.getResults()))
     rewriteValues[std::get<0>(it)] = std::get<1>(it);
 }
 
diff --git a/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp b/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
index 3a0a3a5..9b740e5 100644
--- a/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
+++ b/mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp
@@ -32,8 +32,8 @@ 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();
+  size_t numDests = op.getCases().size();
+  size_t numValues = op.getCaseValues().size();
   if (numDests != numValues) {
     return op.emitOpError(
                "expected number of cases to match the number of case "
@@ -140,23 +140,23 @@ ParseResult ForEachOp::parse(OpAsmParser &parser, OperationState &result) {
 
 void ForEachOp::print(OpAsmPrinter &p) {
   BlockArgument arg = getLoopVariable();
-  p << ' ' << arg << " : " << arg.getType() << " in " << values() << ' ';
-  p.printRegion(region(), /*printEntryBlockArgs=*/false);
+  p << ' ' << arg << " : " << arg.getType() << " in " << getValues() << ' ';
+  p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
   p.printOptionalAttrDict((*this)->getAttrs());
   p << " -> ";
-  p.printSuccessor(successor());
+  p.printSuccessor(getSuccessor());
 }
 
 LogicalResult ForEachOp::verify() {
   // Verify that the operation has exactly one argument.
-  if (region().getNumArguments() != 1)
+  if (getRegion().getNumArguments() != 1)
     return emitOpError("requires exactly one argument");
 
   // Verify that the loop variable and the operand (value range)
   // have compatible types.
   BlockArgument arg = getLoopVariable();
   Type rangeType = pdl::RangeType::get(arg.getType());
-  if (rangeType != values().getType())
+  if (rangeType != getValues().getType())
     return emitOpError("operand must be a range of loop variable type");
 
   return success();
diff --git a/mlir/lib/Rewrite/ByteCode.cpp b/mlir/lib/Rewrite/ByteCode.cpp
index 477d713..ba5519b 100644
--- a/mlir/lib/Rewrite/ByteCode.cpp
+++ b/mlir/lib/Rewrite/ByteCode.cpp
@@ -36,15 +36,15 @@ using namespace mlir::detail;
 PDLByteCodePattern PDLByteCodePattern::create(pdl_interp::RecordMatchOp matchOp,
                                               ByteCodeAddr rewriterAddr) {
   SmallVector<StringRef, 8> generatedOps;
-  if (ArrayAttr generatedOpsAttr = matchOp.generatedOpsAttr())
+  if (ArrayAttr generatedOpsAttr = matchOp.getGeneratedOpsAttr())
     generatedOps =
         llvm::to_vector<8>(generatedOpsAttr.getAsValueRange<StringAttr>());
 
-  PatternBenefit benefit = matchOp.benefit();
+  PatternBenefit benefit = matchOp.getBenefit();
   MLIRContext *ctx = matchOp.getContext();
 
   // Check to see if this is pattern matches a specific operation type.
-  if (Optional<StringRef> rootKind = matchOp.rootKind())
+  if (Optional<StringRef> rootKind = matchOp.getRootKind())
     return PDLByteCodePattern(rewriterAddr, *rootKind, benefit, ctx,
                               generatedOps);
   return PDLByteCodePattern(rewriterAddr, MatchAnyOpTypeTag(), benefit, ctx,
@@ -755,22 +755,22 @@ void Generator::generate(Operation *op, ByteCodeWriter &writer) {
 
 void Generator::generate(pdl_interp::ApplyConstraintOp op,
                          ByteCodeWriter &writer) {
-  assert(constraintToMemIndex.count(op.name()) &&
+  assert(constraintToMemIndex.count(op.getName()) &&
          "expected index for constraint function");
-  writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.name()],
-                op.constParamsAttr());
-  writer.appendPDLValueList(op.args());
+  writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.getName()],
+                op.getConstParamsAttr());
+  writer.appendPDLValueList(op.getArgs());
   writer.append(op.getSuccessors());
 }
 void Generator::generate(pdl_interp::ApplyRewriteOp op,
                          ByteCodeWriter &writer) {
-  assert(externalRewriterToMemIndex.count(op.name()) &&
+  assert(externalRewriterToMemIndex.count(op.getName()) &&
          "expected index for rewrite function");
-  writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.name()],
-                op.constParamsAttr());
-  writer.appendPDLValueList(op.args());
+  writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.getName()],
+                op.getConstParamsAttr());
+  writer.appendPDLValueList(op.getArgs());
 
-  ResultRange results = op.results();
+  ResultRange results = op.getResults();
   writer.append(ByteCodeField(results.size()));
   for (Value result : results) {
     // In debug mode we also record the expected kind of the result, so that we
@@ -786,46 +786,48 @@ void Generator::generate(pdl_interp::ApplyRewriteOp op,
   }
 }
 void Generator::generate(pdl_interp::AreEqualOp op, ByteCodeWriter &writer) {
-  Value lhs = op.lhs();
+  Value lhs = op.getLhs();
   if (lhs.getType().isa<pdl::RangeType>()) {
     writer.append(OpCode::AreRangesEqual);
     writer.appendPDLValueKind(lhs);
-    writer.append(op.lhs(), op.rhs(), op.getSuccessors());
+    writer.append(op.getLhs(), op.getRhs(), op.getSuccessors());
     return;
   }
 
-  writer.append(OpCode::AreEqual, lhs, op.rhs(), op.getSuccessors());
+  writer.append(OpCode::AreEqual, lhs, op.getRhs(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::BranchOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::Branch, SuccessorRange(op.getOperation()));
 }
 void Generator::generate(pdl_interp::CheckAttributeOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::AreEqual, op.attribute(), op.constantValue(),
+  writer.append(OpCode::AreEqual, op.getAttribute(), op.getConstantValue(),
                 op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CheckOperandCountOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::CheckOperandCount, op.operation(), op.count(),
-                static_cast<ByteCodeField>(op.compareAtLeast()),
+  writer.append(OpCode::CheckOperandCount, op.getInputOp(), op.getCount(),
+                static_cast<ByteCodeField>(op.getCompareAtLeast()),
                 op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CheckOperationNameOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::CheckOperationName, op.operation(),
-                OperationName(op.name(), ctx), op.getSuccessors());
+  writer.append(OpCode::CheckOperationName, op.getInputOp(),
+                OperationName(op.getName(), ctx), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CheckResultCountOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::CheckResultCount, op.operation(), op.count(),
-                static_cast<ByteCodeField>(op.compareAtLeast()),
+  writer.append(OpCode::CheckResultCount, op.getInputOp(), op.getCount(),
+                static_cast<ByteCodeField>(op.getCompareAtLeast()),
                 op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CheckTypeOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::AreEqual, op.value(), op.type(), op.getSuccessors());
+  writer.append(OpCode::AreEqual, op.getValue(), op.getType(),
+                op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CheckTypesOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::CheckTypes, op.value(), op.types(), op.getSuccessors());
+  writer.append(OpCode::CheckTypes, op.getValue(), op.getTypes(),
+                op.getSuccessors());
 }
 void Generator::generate(pdl_interp::ContinueOp op, ByteCodeWriter &writer) {
   assert(curLoopLevel > 0 && "encountered pdl_interp.continue at top level");
@@ -834,85 +836,85 @@ void Generator::generate(pdl_interp::ContinueOp op, ByteCodeWriter &writer) {
 void Generator::generate(pdl_interp::CreateAttributeOp op,
                          ByteCodeWriter &writer) {
   // Simply repoint the memory index of the result to the constant.
-  getMemIndex(op.attribute()) = getMemIndex(op.value());
+  getMemIndex(op.getAttribute()) = getMemIndex(op.getValue());
 }
 void Generator::generate(pdl_interp::CreateOperationOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::CreateOperation, op.operation(),
-                OperationName(op.name(), ctx));
-  writer.appendPDLValueList(op.operands());
+  writer.append(OpCode::CreateOperation, op.getResultOp(),
+                OperationName(op.getName(), ctx));
+  writer.appendPDLValueList(op.getInputOperands());
 
   // Add the attributes.
-  OperandRange attributes = op.attributes();
+  OperandRange attributes = op.getInputAttributes();
   writer.append(static_cast<ByteCodeField>(attributes.size()));
-  for (auto it : llvm::zip(op.attributeNames(), op.attributes()))
+  for (auto it : llvm::zip(op.getInputAttributeNames(), attributes))
     writer.append(std::get<0>(it), std::get<1>(it));
-  writer.appendPDLValueList(op.types());
+  writer.appendPDLValueList(op.getInputResultTypes());
 }
 void Generator::generate(pdl_interp::CreateTypeOp op, ByteCodeWriter &writer) {
   // Simply repoint the memory index of the result to the constant.
-  getMemIndex(op.result()) = getMemIndex(op.value());
+  getMemIndex(op.getResult()) = getMemIndex(op.getValue());
 }
 void Generator::generate(pdl_interp::CreateTypesOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::CreateTypes, op.result(),
-                getRangeStorageIndex(op.result()), op.value());
+  writer.append(OpCode::CreateTypes, op.getResult(),
+                getRangeStorageIndex(op.getResult()), op.getValue());
 }
 void Generator::generate(pdl_interp::EraseOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::EraseOp, op.operation());
+  writer.append(OpCode::EraseOp, op.getInputOp());
 }
 void Generator::generate(pdl_interp::ExtractOp op, ByteCodeWriter &writer) {
   OpCode opCode =
-      TypeSwitch<Type, OpCode>(op.result().getType())
+      TypeSwitch<Type, OpCode>(op.getResult().getType())
           .Case([](pdl::OperationType) { return OpCode::ExtractOp; })
           .Case([](pdl::ValueType) { return OpCode::ExtractValue; })
           .Case([](pdl::TypeType) { return OpCode::ExtractType; })
           .Default([](Type) -> OpCode {
             llvm_unreachable("unsupported element type");
           });
-  writer.append(opCode, op.range(), op.index(), op.result());
+  writer.append(opCode, op.getRange(), op.getIndex(), op.getResult());
 }
 void Generator::generate(pdl_interp::FinalizeOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::Finalize);
 }
 void Generator::generate(pdl_interp::ForEachOp op, ByteCodeWriter &writer) {
   BlockArgument arg = op.getLoopVariable();
-  writer.append(OpCode::ForEach, getRangeStorageIndex(op.values()), arg);
+  writer.append(OpCode::ForEach, getRangeStorageIndex(op.getValues()), arg);
   writer.appendPDLValueKind(arg.getType());
-  writer.append(curLoopLevel, op.successor());
+  writer.append(curLoopLevel, op.getSuccessor());
   ++curLoopLevel;
   if (curLoopLevel > maxLoopLevel)
     maxLoopLevel = curLoopLevel;
-  generate(&op.region(), writer);
+  generate(&op.getRegion(), writer);
   --curLoopLevel;
 }
 void Generator::generate(pdl_interp::GetAttributeOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::GetAttribute, op.attribute(), op.operation(),
-                op.nameAttr());
+  writer.append(OpCode::GetAttribute, op.getAttribute(), op.getInputOp(),
+                op.getNameAttr());
 }
 void Generator::generate(pdl_interp::GetAttributeTypeOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::GetAttributeType, op.result(), op.value());
+  writer.append(OpCode::GetAttributeType, op.getResult(), op.getValue());
 }
 void Generator::generate(pdl_interp::GetDefiningOpOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::GetDefiningOp, op.operation());
-  writer.appendPDLValue(op.value());
+  writer.append(OpCode::GetDefiningOp, op.getInputOp());
+  writer.appendPDLValue(op.getValue());
 }
 void Generator::generate(pdl_interp::GetOperandOp op, ByteCodeWriter &writer) {
-  uint32_t index = op.index();
+  uint32_t index = op.getIndex();
   if (index < 4)
     writer.append(static_cast<OpCode>(OpCode::GetOperand0 + index));
   else
     writer.append(OpCode::GetOperandN, index);
-  writer.append(op.operation(), op.value());
+  writer.append(op.getInputOp(), op.getValue());
 }
 void Generator::generate(pdl_interp::GetOperandsOp op, ByteCodeWriter &writer) {
-  Value result = op.value();
-  Optional<uint32_t> index = op.index();
+  Value result = op.getValue();
+  Optional<uint32_t> index = op.getIndex();
   writer.append(OpCode::GetOperands,
                 index.getValueOr(std::numeric_limits<uint32_t>::max()),
-                op.operation());
+                op.getInputOp());
   if (result.getType().isa<pdl::RangeType>())
     writer.append(getRangeStorageIndex(result));
   else
@@ -920,19 +922,19 @@ void Generator::generate(pdl_interp::GetOperandsOp op, ByteCodeWriter &writer) {
   writer.append(result);
 }
 void Generator::generate(pdl_interp::GetResultOp op, ByteCodeWriter &writer) {
-  uint32_t index = op.index();
+  uint32_t index = op.getIndex();
   if (index < 4)
     writer.append(static_cast<OpCode>(OpCode::GetResult0 + index));
   else
     writer.append(OpCode::GetResultN, index);
-  writer.append(op.operation(), op.value());
+  writer.append(op.getInputOp(), op.getValue());
 }
 void Generator::generate(pdl_interp::GetResultsOp op, ByteCodeWriter &writer) {
-  Value result = op.value();
-  Optional<uint32_t> index = op.index();
+  Value result = op.getValue();
+  Optional<uint32_t> index = op.getIndex();
   writer.append(OpCode::GetResults,
                 index.getValueOr(std::numeric_limits<uint32_t>::max()),
-                op.operation());
+                op.getInputOp());
   if (result.getType().isa<pdl::RangeType>())
     writer.append(getRangeStorageIndex(result));
   else
@@ -940,71 +942,71 @@ void Generator::generate(pdl_interp::GetResultsOp op, ByteCodeWriter &writer) {
   writer.append(result);
 }
 void Generator::generate(pdl_interp::GetUsersOp op, ByteCodeWriter &writer) {
-  Value operations = op.operations();
+  Value operations = op.getOperations();
   ByteCodeField rangeIndex = getRangeStorageIndex(operations);
   writer.append(OpCode::GetUsers, operations, rangeIndex);
-  writer.appendPDLValue(op.value());
+  writer.appendPDLValue(op.getValue());
 }
 void Generator::generate(pdl_interp::GetValueTypeOp op,
                          ByteCodeWriter &writer) {
   if (op.getType().isa<pdl::RangeType>()) {
-    Value result = op.result();
+    Value result = op.getResult();
     writer.append(OpCode::GetValueRangeTypes, result,
-                  getRangeStorageIndex(result), op.value());
+                  getRangeStorageIndex(result), op.getValue());
   } else {
-    writer.append(OpCode::GetValueType, op.result(), op.value());
+    writer.append(OpCode::GetValueType, op.getResult(), op.getValue());
   }
 }
 
 void Generator::generate(pdl_interp::InferredTypesOp op,
                          ByteCodeWriter &writer) {
   // InferType maps to a null type as a marker for inferring result types.
-  getMemIndex(op.type()) = getMemIndex(Type());
+  getMemIndex(op.getResult()) = getMemIndex(Type());
 }
 void Generator::generate(pdl_interp::IsNotNullOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::IsNotNull, op.value(), op.getSuccessors());
+  writer.append(OpCode::IsNotNull, op.getValue(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::RecordMatchOp op, ByteCodeWriter &writer) {
   ByteCodeField patternIndex = patterns.size();
   patterns.emplace_back(PDLByteCodePattern::create(
-      op, rewriterToAddr[op.rewriter().getLeafReference().getValue()]));
+      op, rewriterToAddr[op.getRewriter().getLeafReference().getValue()]));
   writer.append(OpCode::RecordMatch, patternIndex,
-                SuccessorRange(op.getOperation()), op.matchedOps());
-  writer.appendPDLValueList(op.inputs());
+                SuccessorRange(op.getOperation()), op.getMatchedOps());
+  writer.appendPDLValueList(op.getInputs());
 }
 void Generator::generate(pdl_interp::ReplaceOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::ReplaceOp, op.operation());
-  writer.appendPDLValueList(op.replValues());
+  writer.append(OpCode::ReplaceOp, op.getInputOp());
+  writer.appendPDLValueList(op.getReplValues());
 }
 void Generator::generate(pdl_interp::SwitchAttributeOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::SwitchAttribute, op.attribute(), op.caseValuesAttr(),
-                op.getSuccessors());
+  writer.append(OpCode::SwitchAttribute, op.getAttribute(),
+                op.getCaseValuesAttr(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::SwitchOperandCountOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::SwitchOperandCount, op.operation(), op.caseValuesAttr(),
-                op.getSuccessors());
+  writer.append(OpCode::SwitchOperandCount, op.getInputOp(),
+                op.getCaseValuesAttr(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::SwitchOperationNameOp op,
                          ByteCodeWriter &writer) {
-  auto cases = llvm::map_range(op.caseValuesAttr(), [&](Attribute attr) {
+  auto cases = llvm::map_range(op.getCaseValuesAttr(), [&](Attribute attr) {
     return OperationName(attr.cast<StringAttr>().getValue(), ctx);
   });
-  writer.append(OpCode::SwitchOperationName, op.operation(), cases,
+  writer.append(OpCode::SwitchOperationName, op.getInputOp(), cases,
                 op.getSuccessors());
 }
 void Generator::generate(pdl_interp::SwitchResultCountOp op,
                          ByteCodeWriter &writer) {
-  writer.append(OpCode::SwitchResultCount, op.operation(), op.caseValuesAttr(),
-                op.getSuccessors());
+  writer.append(OpCode::SwitchResultCount, op.getInputOp(),
+                op.getCaseValuesAttr(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::SwitchTypeOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::SwitchType, op.value(), op.caseValuesAttr(),
+  writer.append(OpCode::SwitchType, op.getValue(), op.getCaseValuesAttr(),
                 op.getSuccessors());
 }
 void Generator::generate(pdl_interp::SwitchTypesOp op, ByteCodeWriter &writer) {
-  writer.append(OpCode::SwitchTypes, op.value(), op.caseValuesAttr(),
+  writer.append(OpCode::SwitchTypes, op.getValue(), op.getCaseValuesAttr(),
                 op.getSuccessors());
 }