[mlir] Flip PDL to use Both accessors

[rriddle]

Summary

This allows for incrementally updating the old API usages without
needing to update everything at once. PDL will be left on Both
for a little bit and then flipped to prefixed when all APIs have been
updated.

Depends on D134386

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

def PDL_Dialect : Dialect {
   let name = "pdl";
   let cppNamespace = "::mlir::pdl";
 
   let useDefaultTypePrinterParser = 1;
   let extraClassDeclaration = [{
     void registerTypes();
   }];
 
-  // FIXME: Prefixed accessors overlap with builtin Operation members. Flip
-  // once resolved.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Raw;
+  // FIXME: Flip to prefixed.
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLDIALECT

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

let description = [{
     %type = pdl.type : i32
     %attr = pdl.attribute : %type
 
     // Define an attribute with a constant value:
     %attr = pdl.attribute = "hello"
     ```
   }];
 
-  let arguments = (ins Optional<PDL_Type>:$type,
+  let arguments = (ins Optional<PDL_Type>:$valueType,
                        OptionalAttr<AnyAttr>:$value);
   let results = (outs PDL_Attribute:$attr);
-  let assemblyFormat = "(`:` $type^)? (`=` $value^)? attr-dict-with-keyword";
+  let assemblyFormat = "(`:` $valueType^)? (`=` $value^)? attr-dict-with-keyword";
 
   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 description = [{
     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 arguments = (ins PDL_Operation:$opValue);
+  let assemblyFormat = "$opValue attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandOp
     : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
let description = [{
     %operand = pdl.operand
 
     // Define an external operand with an expected type:
     %type = pdl.type : i32
     %operand = pdl.operand : %type
     ```
   }];
 
-  let arguments = (ins Optional<PDL_Type>:$type);
-  let results = (outs PDL_Value:$val);
-  let assemblyFormat = "(`:` $type^)? attr-dict";
+  let arguments = (ins Optional<PDL_Type>:$valueType);
+  let results = (outs PDL_Value:$value);
+  let assemblyFormat = "(`:` $valueType^)? attr-dict";
 
   let builders = [
     OpBuilder<(ins), [{
       build($_builder, $_state, $_builder.getType<ValueType>(), Value());
     }]>,
   ];
   let hasVerifier = 1;
 }
let description = [{
     %operands = pdl.operands
 
     // Define a range of input operands with expected types:
     %types = pdl.types : [i32, i64, i32]
     %typed_operands = pdl.operands : %types
     ```
   }];
 
-  let arguments = (ins Optional<PDL_RangeOf<PDL_Type>>:$type);
-  let results = (outs PDL_RangeOf<PDL_Value>:$val);
-  let assemblyFormat = "(`:` $type^)? attr-dict";
+  let arguments = (ins Optional<PDL_RangeOf<PDL_Type>>:$valueType);
+  let results = (outs PDL_RangeOf<PDL_Value>:$value);
+  let assemblyFormat = "(`:` $valueType^)? attr-dict";
 
   let builders = [
     OpBuilder<(ins), [{
       build($_builder, $_state, RangeType::get($_builder.getType<ValueType>()),
             Value());
     }]>,
   ];
   let hasVerifier = 1;
let description = [{
     ```mlir
     // We can match the results as so:
     %result = pdl.type
     %otherResults = pdl.types
     %op = pdl.operation "foo.op" -> (%result, %otherResults : !pdl.type, !pdl.range<type>)
     ```
   }];
 
-  let arguments = (ins OptionalAttr<StrAttr>:$name,
-                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$operands,
-                       Variadic<PDL_Attribute>:$attributes,
-                       StrArrayAttr:$attributeNames,
-                       Variadic<PDL_InstOrRangeOf<PDL_Type>>:$types);
+  let arguments = (ins OptionalAttr<StrAttr>:$opName,
+                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$operandValues,
+                       Variadic<PDL_Attribute>:$attributeValues,
+                       StrArrayAttr:$attributeValueNames,
+                       Variadic<PDL_InstOrRangeOf<PDL_Type>>:$typeValues);
   let results = (outs PDL_Operation:$op);
   let assemblyFormat = [{
-    ($name^)? (`(` $operands^ `:` type($operands) `)`)?
-    custom<OperationOpAttributes>($attributes, $attributeNames)
-    (`->` `(` $types^ `:` type($types) `)`)? attr-dict
+    ($opName^)? (`(` $operandValues^ `:` type($operandValues) `)`)?
+    custom<OperationOpAttributes>($attributeValues, $attributeValueNames)
+    (`->` `(` $typeValues^ `:` type($typeValues) `)`)? attr-dict
   }];
 
   let builders = [
     OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
       CArg<"ValueRange", "llvm::None">:$operandValues,
       CArg<"ArrayRef<StringRef>", "llvm::None">:$attrNames,
       CArg<"ValueRange", "llvm::None">:$attrValues,
       CArg<"ValueRange", "llvm::None">:$resultTypes), [{
pdl.pattern : benefit(1) {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
   }];
 
   let arguments = (ins ConfinedAttr<I16Attr, [IntNonNegative]>:$benefit,
                        OptionalAttr<SymbolNameAttr>:$sym_name);
-  let regions = (region SizedRegion<1>:$body);
+  let regions = (region SizedRegion<1>:$bodyRegion);
   let assemblyFormat = [{
-    ($sym_name^)? `:` `benefit` `(` $benefit `)` attr-dict-with-keyword $body
+    ($sym_name^)? `:` `benefit` `(` $benefit `)` attr-dict-with-keyword $bodyRegion
   }];
 
   let builders = [
     OpBuilder<(ins CArg<"Optional<uint16_t>", "1">:$benefit,
                    CArg<"Optional<StringRef>", "llvm::None">:$name)>,
   ];
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
let description = [{
 
     // Replace root node with a range of values:
     pdl.replace %root with (%vals : !pdl.range<value>)
 
     // Replace root with another operation:
     pdl.replace %root with %otherOp
     ```
   }];
-  let arguments = (ins PDL_Operation:$operation,
+  let arguments = (ins PDL_Operation:$opValue,
                        Optional<PDL_Operation>:$replOperation,
                        Variadic<PDL_InstOrRangeOf<PDL_Value>>:$replValues);
   let assemblyFormat = [{
-    $operation `with` (`(` $replValues^ `:` type($replValues) `)`)?
+    $opValue `with` (`(` $replValues^ `:` type($replValues) `)`)?
     ($replOperation^)? attr-dict
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
pdl.rewrite {
       pdl.replace %root2 with %op2
     }
     ```
   }];
 
   let arguments = (ins Optional<PDL_Operation>:$root,
                        OptionalAttr<StrAttr>:$name,
                        Variadic<PDL_AnyType>:$externalArgs);
-  let regions = (region AnyRegion:$body);
+  let regions = (region AnyRegion:$bodyRegion);
   let assemblyFormat = [{
     ($root^)? (`with` $name^ (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
-              ($body^)?
+              ($bodyRegion^)?
     attr-dict-with-keyword
   }];
   let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
let description = [{
     // Define a type:
     %type = pdl.type
 
     // Define a type with a constant value:
     %type = pdl.type : i32
     ```
   }];
 
-  let arguments = (ins OptionalAttr<TypeAttr>:$type);
+  let arguments = (ins OptionalAttr<TypeAttr>:$constantType);
   let results = (outs PDL_Type:$result);
-  let assemblyFormat = "attr-dict (`:` $type^)?";
+  let assemblyFormat = "attr-dict (`:` $constantType^)?";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
 def PDL_TypesOp : PDL_Op<"types"> {
let description = [{
     // Define a range of types:
     %types = pdl.types
 
     // Define a range of types with a range of constant values:
     %types = pdl.types : [i32, i64, i32]
     ```
   }];
 
-  let arguments = (ins OptionalAttr<TypeArrayAttr>:$types);
+  let arguments = (ins OptionalAttr<TypeArrayAttr>:$constantTypes);
   let results = (outs PDL_RangeOf<PDL_Type>:$result);
-  let assemblyFormat = "attr-dict (`:` $types^)?";
+  let assemblyFormat = "attr-dict (`:` $constantTypes^)?";
   let hasVerifier = 1;
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLOPS

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

void PatternLowering::generate(SuccessNode *successNode, Block *&currentBlock) {
   // Process any values used in the rewrite that are defined in the match.
   std::vector<Value> mappedMatchValues;
   mappedMatchValues.reserve(usedMatchValues.size());
   for (Position *position : usedMatchValues)
     mappedMatchValues.push_back(getValueAt(currentBlock, position));
 
   // Collect the set of operations generated by the rewriter.
   SmallVector<StringRef, 4> generatedOps;
-  for (auto op : pattern.getRewriter().body().getOps<pdl::OperationOp>())
-    generatedOps.push_back(*op.name());
+  for (auto op :
+       pattern.getRewriter().getBodyRegion().getOps<pdl::OperationOp>())
+    generatedOps.push_back(*op.getOpName());
   ArrayAttr generatedOpsAttr;
   if (!generatedOps.empty())
     generatedOpsAttr = builder.getStrArrayAttr(generatedOps);
 
   // Grab the root kind if present.
   StringAttr rootKindAttr;
   if (pdl::OperationOp rootOp = root.getDefiningOp<pdl::OperationOp>())
-    if (Optional<StringRef> rootKind = rootOp.name())
+    if (Optional<StringRef> rootKind = rootOp.getOpName())
       rootKindAttr = builder.getStringAttr(*rootKind);
 
   builder.setInsertionPointToEnd(currentBlock);
   builder.create<pdl_interp::RecordMatchOp>(
       pattern.getLoc(), mappedMatchValues, locOps.getArrayRef(),
       rewriterFuncRef, rootKindAttr, generatedOpsAttr, pattern.benefitAttr(),
       failureBlockStack.back());
 }
auto mapRewriteValue = [&](Value oldValue) {
     // Prefer materializing constants directly when possible.
     Operation *oldOp = oldValue.getDefiningOp();
     if (pdl::AttributeOp attrOp = dyn_cast<pdl::AttributeOp>(oldOp)) {
       if (Attribute value = attrOp.valueAttr()) {
         return newValue = builder.create<pdl_interp::CreateAttributeOp>(
                    attrOp.getLoc(), value);
       }
     } else if (pdl::TypeOp typeOp = dyn_cast<pdl::TypeOp>(oldOp)) {
-      if (TypeAttr type = typeOp.typeAttr()) {
+      if (TypeAttr type = typeOp.getConstantTypeAttr()) {
         return newValue = builder.create<pdl_interp::CreateTypeOp>(
                    typeOp.getLoc(), type);
       }
     } else if (pdl::TypesOp typeOp = dyn_cast<pdl::TypesOp>(oldOp)) {
-      if (ArrayAttr type = typeOp.typesAttr()) {
+      if (ArrayAttr type = typeOp.getConstantTypesAttr()) {
         return newValue = builder.create<pdl_interp::CreateTypesOp>(
                    typeOp.getLoc(), typeOp.getType(), type);
       }
     }
 
     // Otherwise, add this as an input to the rewriter.
     Position *inputPos = valueToPosition.lookup(oldValue);
     assert(inputPos && "expected value to be a pattern input");
Value newAttr = builder.create<pdl_interp::CreateAttributeOp>(
       attrOp.getLoc(), attrOp.valueAttr());
   rewriteValues[attrOp] = newAttr;
 }
 
 void PatternLowering::generateRewriter(
     pdl::EraseOp eraseOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   builder.create<pdl_interp::EraseOp>(eraseOp.getLoc(),
-                                      mapRewriteValue(eraseOp.operation()));
+                                      mapRewriteValue(eraseOp.getOpValue()));
 }
 
 void PatternLowering::generateRewriter(
     pdl::OperationOp operationOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   SmallVector<Value, 4> operands;
-  for (Value operand : operationOp.operands())
+  for (Value operand : operationOp.getOperandValues())
     operands.push_back(mapRewriteValue(operand));
 
   SmallVector<Value, 4> attributes;
-  for (Value attr : operationOp.attributes())
+  for (Value attr : operationOp.getAttributeValues())
     attributes.push_back(mapRewriteValue(attr));
 
   bool hasInferredResultTypes = false;
   SmallVector<Value, 2> types;
   generateOperationResultTypeRewriter(operationOp, mapRewriteValue, types,
                                       rewriteValues, hasInferredResultTypes);
 
   // Create the new operation.
   Location loc = operationOp.getLoc();
   Value createdOp = builder.create<pdl_interp::CreateOperationOp>(
-      loc, *operationOp.name(), types, hasInferredResultTypes, operands,
-      attributes, operationOp.attributeNames());
+      loc, *operationOp.getOpName(), types, hasInferredResultTypes, operands,
+      attributes, operationOp.getAttributeValueNames());
   rewriteValues[operationOp.op()] = createdOp;
 
   // Generate accesses for any results that have their types constrained.
   // Handle the case where there is a single range representing all of the
   // result types.
-  OperandRange resultTys = operationOp.types();
+  OperandRange resultTys = operationOp.getTypeValues();
   if (resultTys.size() == 1 && resultTys[0].getType().isa<pdl::RangeType>()) {
     Value &type = rewriteValues[resultTys[0]];
     if (!type) {
       auto results = builder.create<pdl_interp::GetResultsOp>(loc, createdOp);
       type = builder.create<pdl_interp::GetValueTypeOp>(loc, results);
     }
     return;
   }
void PatternLowering::generateRewriter(
     function_ref<Value(Value)> mapRewriteValue) {
   SmallVector<Value, 4> replOperands;
 
   // If the replacement was another operation, get its results. `pdl` allows
   // for using an operation for simplicitly, but the interpreter isn't as
   // user facing.
   if (Value replOp = replaceOp.replOperation()) {
     // Don't use replace if we know the replaced operation has no results.
-    auto opOp = replaceOp.operation().getDefiningOp<pdl::OperationOp>();
-    if (!opOp || !opOp.types().empty()) {
+    auto opOp = replaceOp.getOpValue().getDefiningOp<pdl::OperationOp>();
+    if (!opOp || !opOp.getTypeValues().empty()) {
       replOperands.push_back(builder.create<pdl_interp::GetResultsOp>(
           replOp.getLoc(), mapRewriteValue(replOp)));
     }
   } else {
     for (Value operand : replaceOp.replValues())
       replOperands.push_back(mapRewriteValue(operand));
   }
 
   // If there are no replacement values, just create an erase instead.
   if (replOperands.empty()) {
-    builder.create<pdl_interp::EraseOp>(replaceOp.getLoc(),
-                                        mapRewriteValue(replaceOp.operation()));
+    builder.create<pdl_interp::EraseOp>(
+        replaceOp.getLoc(), mapRewriteValue(replaceOp.getOpValue()));
     return;
   }
 
-  builder.create<pdl_interp::ReplaceOp>(
-      replaceOp.getLoc(), mapRewriteValue(replaceOp.operation()), replOperands);
+  builder.create<pdl_interp::ReplaceOp>(replaceOp.getLoc(),
+                                        mapRewriteValue(replaceOp.getOpValue()),
+                                        replOperands);
 }
 
 void PatternLowering::generateRewriter(
     pdl::ResultOp resultOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   rewriteValues[resultOp] = builder.create<pdl_interp::GetResultOp>(
       resultOp.getLoc(), builder.getType<pdl::ValueType>(),
       mapRewriteValue(resultOp.parent()), resultOp.index());
 }
 
 void PatternLowering::generateRewriter(
     pdl::ResultsOp resultOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   rewriteValues[resultOp] = builder.create<pdl_interp::GetResultsOp>(
       resultOp.getLoc(), resultOp.getType(), mapRewriteValue(resultOp.parent()),
       resultOp.index());
 }
 
 void PatternLowering::generateRewriter(
     pdl::TypeOp typeOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   // If the type isn't constant, the users (e.g. OperationOp) will resolve this
   // type.
-  if (TypeAttr typeAttr = typeOp.typeAttr()) {
+  if (TypeAttr typeAttr = typeOp.getConstantTypeAttr()) {
     rewriteValues[typeOp] =
         builder.create<pdl_interp::CreateTypeOp>(typeOp.getLoc(), typeAttr);
   }
 }
 
 void PatternLowering::generateRewriter(
     pdl::TypesOp typeOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   // If the type isn't constant, the users (e.g. OperationOp) will resolve this
   // type.
-  if (ArrayAttr typeAttr = typeOp.typesAttr()) {
+  if (ArrayAttr typeAttr = typeOp.getConstantTypesAttr()) {
     rewriteValues[typeOp] = builder.create<pdl_interp::CreateTypesOp>(
         typeOp.getLoc(), typeOp.getType(), typeAttr);
   }
 }
 
 void PatternLowering::generateOperationResultTypeRewriter(
     pdl::OperationOp op, function_ref<Value(Value)> mapRewriteValue,
     SmallVectorImpl<Value> &types, DenseMap<Value, Value> &rewriteValues,
     bool &hasInferredResultTypes) {
   Block *rewriterBlock = op->getBlock();
 
   // Try to handle resolution for each of the result types individually. This is
   // preferred over type inferrence because it will allow for us to use existing
   // types directly, as opposed to trying to rebuild the type list.
-  OperandRange resultTypeValues = op.types();
+  OperandRange resultTypeValues = op.getTypeValues();
   auto tryResolveResultTypes = [&] {
     types.reserve(resultTypeValues.size());
     for (const auto &it : llvm::enumerate(resultTypeValues)) {
       Value resultType = it.value();
 
       // Check for an already translated value.
       if (Value existingRewriteValue = rewriteValues.lookup(resultType)) {
         types.push_back(existingRewriteValue);
for (OpOperand &use : op.op().getUses()) {
     // replacement value, not the operation being replaced.
     pdl::ReplaceOp replOpUser = dyn_cast<pdl::ReplaceOp>(use.getOwner());
     if (!replOpUser || use.getOperandNumber() == 0)
       continue;
     // Make sure the replaced operation was defined before this one. PDL
     // rewrites only have single block regions, so if the op isn't in the
     // rewriter block (i.e. the current block of the operation) we already know
     // it dominates (i.e. it's in the matcher).
-    Value replOpVal = replOpUser.operation();
+    Value replOpVal = replOpUser.getOpValue();
     Operation *replacedOp = replOpVal.getDefiningOp();
     if (replacedOp->getBlock() == rewriterBlock &&
         !replacedOp->isBeforeInBlock(op))
       continue;
 
     Value replacedOpResults = builder.create<pdl_interp::GetResultsOp>(
         replacedOp->getLoc(), mapRewriteValue(replOpVal));
     types.push_back(builder.create<pdl_interp::GetValueTypeOp>(

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

static void getTreePredicates(std::vector<PositionalPredicate> &predList,
                               Value val, PredicateBuilder &builder,
                               DenseMap<Value, Position *> &inputs,
                               AttributePosition *pos) {
   assert(val.getType().isa<pdl::AttributeType>() && "expected attribute type");
   pdl::AttributeOp attr = cast<pdl::AttributeOp>(val.getDefiningOp());
   predList.emplace_back(pos, builder.getIsNotNull());
 
   // If the attribute has a type or value, add a constraint.
-  if (Value type = attr.type())
+  if (Value type = attr.getValueType())
     getTreePredicates(predList, type, builder, inputs, builder.getType(pos));
   else if (Attribute value = attr.valueAttr())
     predList.emplace_back(pos, builder.getAttributeConstraint(value));
 }
 
 /// Collect all of the predicates for the given operand position.
 static void getOperandTreePredicates(std::vector<PositionalPredicate> &predList,
                                      Value val, PredicateBuilder &builder,
                                      DenseMap<Value, Position *> &inputs,
                                      Position *pos) {
   Type valueType = val.getType();
   bool isVariadic = valueType.isa<pdl::RangeType>();
 
   // If this is a typed operand, add a type constraint.
   TypeSwitch<Operation *>(val.getDefiningOp())
       .Case<pdl::OperandOp, pdl::OperandsOp>([&](auto op) {
         // Prevent traversal into a null value if the operand has a proper
         // index.
         if (std::is_same<pdl::OperandOp, decltype(op)>::value ||
             cast<OperandGroupPosition>(pos)->getOperandGroupNumber())
           predList.emplace_back(pos, builder.getIsNotNull());
 
-        if (Value type = op.type())
+        if (Value type = op.getValueType())
           getTreePredicates(predList, type, builder, inputs,
                             builder.getType(pos));
       })
       .Case<pdl::ResultOp, pdl::ResultsOp>([&](auto op) {
         Optional<unsigned> index = op.index();
 
         // Prevent traversal into a null value if the result has a proper index.
         if (index)
static void getTreePredicates(std::vector<PositionalPredicate> &predList,
   pdl::OperationOp op = cast<pdl::OperationOp>(val.getDefiningOp());
   OperationPosition *opPos = cast<OperationPosition>(pos);
 
   // Ensure getDefiningOp returns a non-null operation.
   if (!opPos->isRoot())
     predList.emplace_back(pos, builder.getIsNotNull());
 
   // Check that this is the correct root operation.
-  if (Optional<StringRef> opName = op.name())
+  if (Optional<StringRef> opName = op.getOpName())
     predList.emplace_back(pos, builder.getOperationName(*opName));
 
   // Check that the operation has the proper number of operands. If there are
   // any variable length operands, we check a minimum instead of an exact count.
-  OperandRange operands = op.operands();
+  OperandRange operands = op.getOperandValues();
   unsigned minOperands = getNumNonRangeValues(operands);
   if (minOperands != operands.size()) {
     if (minOperands)
       predList.emplace_back(pos, builder.getOperandCountAtLeast(minOperands));
   } else {
     predList.emplace_back(pos, builder.getOperandCount(minOperands));
   }
 
   // Check that the operation has the proper number of results. If there are
   // any variable length results, we check a minimum instead of an exact count.
-  OperandRange types = op.types();
+  OperandRange types = op.getTypeValues();
   unsigned minResults = getNumNonRangeValues(types);
   if (minResults == types.size())
     predList.emplace_back(pos, builder.getResultCount(types.size()));
   else if (minResults)
     predList.emplace_back(pos, builder.getResultCountAtLeast(minResults));
 
   // Recurse into any attributes, operands, or results.
-  for (auto it : llvm::zip(op.attributeNames(), op.attributes())) {
+  for (auto [attrName, attr] :
+       llvm::zip(op.getAttributeValueNames(), op.getAttributeValues())) {
     getTreePredicates(
-        predList, std::get<1>(it), builder, inputs,
-        builder.getAttribute(opPos,
-                             std::get<0>(it).cast<StringAttr>().getValue()));
+        predList, attr, builder, inputs,
+        builder.getAttribute(opPos, attrName.cast<StringAttr>().getValue()));
   }
 
   // Process the operands and results of the operation. For all values up to
   // the first variable length value, we use the concrete operand/result
   // number. After that, we use the "group" given that we can't know the
   // concrete indices until runtime. If there is only one variadic operand
   // group, we treat it as all of the operands/results of the operation.
   /// Operands.

 }
 
 static void getTreePredicates(std::vector<PositionalPredicate> &predList,
                               Value val, PredicateBuilder &builder,
                               DenseMap<Value, Position *> &inputs,
                               TypePosition *pos) {
   // Check for a constraint on a constant type.
   if (pdl::TypeOp typeOp = val.getDefiningOp<pdl::TypeOp>()) {
-    if (Attribute type = typeOp.typeAttr())
+    if (Attribute type = typeOp.getConstantTypeAttr())
       predList.emplace_back(pos, builder.getTypeConstraint(type));
   } else if (pdl::TypesOp typeOp = val.getDefiningOp<pdl::TypesOp>()) {
-    if (Attribute typeAttr = typeOp.typesAttr())
+    if (Attribute typeAttr = typeOp.getConstantTypesAttr())
       predList.emplace_back(pos, builder.getTypeConstraint(typeAttr));
   }
 }
 
 /// Collect the tree predicates anchored at the given value.
 static void getTreePredicates(std::vector<PositionalPredicate> &predList,
                               Value val, PredicateBuilder &builder,
                               DenseMap<Value, Position *> &inputs,

 }
 
 /// Collect all of the predicates that cannot be determined via walking the
 /// tree.
 static void getNonTreePredicates(pdl::PatternOp pattern,
                                  std::vector<PositionalPredicate> &predList,
                                  PredicateBuilder &builder,
                                  DenseMap<Value, Position *> &inputs) {
-  for (Operation &op : pattern.body().getOps()) {
+  for (Operation &op : pattern.getBodyRegion().getOps()) {
     TypeSwitch<Operation *>(&op)
         .Case([&](pdl::AttributeOp attrOp) {
           getAttributePredicates(attrOp, predList, builder, inputs);
         })
         .Case<pdl::ApplyNativeConstraintOp>([&](auto constraintOp) {
           getConstraintPredicates(constraintOp, predList, builder, inputs);
         })
         .Case<pdl::ResultOp, pdl::ResultsOp>([&](auto resultOp) {
           getResultPredicates(resultOp, predList, builder, inputs);
         })
         .Case([&](pdl::TypeOp typeOp) {
           getTypePredicates(
-              typeOp, [&] { return typeOp.typeAttr(); }, builder, inputs);
+              typeOp, [&] { return typeOp.getConstantTypeAttr(); }, builder,
+              inputs);
         })
         .Case([&](pdl::TypesOp typeOp) {
           getTypePredicates(
-              typeOp, [&] { return typeOp.typesAttr(); }, builder, inputs);
+              typeOp, [&] { return typeOp.getConstantTypesAttr(); }, builder,
+              inputs);
         });
   }
 }
 
 namespace {
 
 /// An op accepting a value at an optional index.
 struct OpIndex {
   Value parent;
   Optional<unsigned> index;
 };
 
 /// The parent and operand index of each operation for each root, stored
 /// as a nested map [root][operation].
 using ParentMaps = DenseMap<Value, DenseMap<Value, OpIndex>>;
 
 } // namespace
 
 /// Given a pattern, determines the set of roots present in this pattern.
 /// These are the operations whose results are not consumed by other operations.
 static SmallVector<Value> detectRoots(pdl::PatternOp pattern) {
   // First, collect all the operations that are used as operands
   // to other operations. These are not roots by default.
   DenseSet<Value> used;
-  for (auto operationOp : pattern.body().getOps<pdl::OperationOp>()) {
-    for (Value operand : operationOp.operands())
+  for (auto operationOp : pattern.getBodyRegion().getOps<pdl::OperationOp>()) {
+    for (Value operand : operationOp.getOperandValues())
       TypeSwitch<Operation *>(operand.getDefiningOp())
           .Case<pdl::ResultOp, pdl::ResultsOp>(
               [&used](auto resultOp) { used.insert(resultOp.parent()); });
   }
 
   // Remove the specified root from the use set, so that we can
   // always select it as a root, even if it is used by other operations.
   if (Value root = pattern.getRewriter().root())
     used.erase(root);
 
   // Finally, collect all the unused operations.
   SmallVector<Value> roots;
-  for (Value operationOp : pattern.body().getOps<pdl::OperationOp>())
+  for (Value operationOp : pattern.getBodyRegion().getOps<pdl::OperationOp>())
     if (!used.contains(operationOp))
       roots.push_back(operationOp);
 
   return roots;
 }
 
 /// Given a list of candidate roots, builds the cost graph for connecting them.
 /// The graph is formed by traversing the DAG of operations starting from each
while (!toVisit.empty()) {
       // Mark the root and depth of the value.
       connectorsRootsDepths[entry.value].push_back({root, entry.depth});
 
       // Traverse the operands of an operation and result ops.
       // We intentionally do not traverse attributes and types, because those
       // are expensive to join on.
       TypeSwitch<Operation *>(entry.value.getDefiningOp())
           .Case<pdl::OperationOp>([&](auto operationOp) {
-            OperandRange operands = operationOp.operands();
+            OperandRange operands = operationOp.getOperandValues();
             // Special case when we pass all the operands in one range.
             // For those, the index is empty.
             if (operands.size() == 1 &&
                 operands[0].getType().isa<pdl::RangeType>()) {
               toVisit.emplace(operands[0], entry.value, llvm::None,
                               entry.depth + 1);
               return;
             }
 
             // Default case: visit all the operands.
-            for (const auto &p : llvm::enumerate(operationOp.operands()))
+            for (const auto &p :
+                 llvm::enumerate(operationOp.getOperandValues()))
               toVisit.emplace(p.value(), entry.value, p.index(),
                               entry.depth + 1);
           })
           .Case<pdl::ResultOp, pdl::ResultsOp>([&](auto resultOp) {
             toVisit.emplace(resultOp.parent(), entry.value, resultOp.index(),
                             entry.depth);
           });
     }
static void buildCostGraph(ArrayRef<Value> roots, RootOrderingGraph &graph,
 
   assert((llvm::hasSingleElement(roots) || graph.size() == roots.size()) &&
          "the pattern contains a candidate root disconnected from the others");
 }
 
 /// Returns true if the operand at the given index needs to be queried using an
 /// operand group, i.e., if it is variadic itself or follows a variadic operand.
 static bool useOperandGroup(pdl::OperationOp op, unsigned index) {
-  OperandRange operands = op.operands();
+  OperandRange operands = op.getOperandValues();
   assert(index < operands.size() && "operand index out of range");
   for (unsigned i = 0; i <= index; ++i)
     if (operands[i].getType().isa<pdl::RangeType>())
       return true;
   return false;
 }
 
 /// Visit a node during upward traversal.
TypeSwitch<Operation *>(value.getDefiningOp())
 
         // Compare the operand(s) of the user against the input value(s).
         Position *operandPos;
         if (!opIndex.index) {
           // We are querying all the operands of the operation.
           operandPos = builder.getAllOperands(opPos);
         } else if (useOperandGroup(operationOp, *opIndex.index)) {
           // We are querying an operand group.
-          Type type = operationOp.operands()[*opIndex.index].getType();
+          Type type = operationOp.getOperandValues()[*opIndex.index].getType();
           bool variadic = type.isa<pdl::RangeType>();
           operandPos = builder.getOperandGroup(opPos, opIndex.index, variadic);
         } else {
           // We are querying an individual operand.
           operandPos = builder.getOperand(opPos, *opIndex.index);
         }
         predList.emplace_back(operandPos, builder.getEqualTo(pos));
 

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

if (visited.contains(op))
     return;
 
   // Mark as visited.
   visited.insert(op);
 
   // Traverse the operands / parent.
   TypeSwitch<Operation *>(op)
       .Case<OperationOp>([&visited](auto operation) {
-        for (Value operand : operation.operands())
+        for (Value operand : operation.getOperandValues())
           visit(operand.getDefiningOp(), visited);
       })
       .Case<ResultOp, ResultsOp>([&visited](auto result) {
         visit(result.parent().getDefiningOp(), visited);
       });
 
   // Traverse the users.
   for (Operation *user : op->getUsers())
LogicalResult ApplyNativeRewriteOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AttributeOp::verify() {
-  Value attrType = type();
+  Value attrType = getValueType();
   Optional<Attribute> attrValue = value();
 
   if (!attrValue) {
     if (isa<RewriteOp>((*this)->getParentOp()))
       return emitOpError(
           "expected constant value when specified within a `pdl.rewrite`");
     return verifyHasBindingUse(*this);
   }
static LogicalResult verifyResultTypesAreInferrable(OperationOp op,
   Block *rewriterBlock = op->getBlock();
   auto canInferTypeFromUse = [&](OpOperand &use) {
     // If the use is within a ReplaceOp and isn't the operation being replaced
     // (i.e. is not the first operand of the replacement), we can infer a type.
     ReplaceOp replOpUser = dyn_cast<ReplaceOp>(use.getOwner());
     if (!replOpUser || use.getOperandNumber() == 0)
       return false;
     // Make sure the replaced operation was defined before this one.
-    Operation *replacedOp = replOpUser.operation().getDefiningOp();
+    Operation *replacedOp = replOpUser.getOpValue().getDefiningOp();
     return replacedOp->getBlock() != rewriterBlock ||
            replacedOp->isBeforeInBlock(op);
   };
 
   // Check to see if the uses of the operation itself can be used to infer
   // types.
   if (llvm::any_of(op.op().getUses(), canInferTypeFromUse))
     return success();
 
   // Handle the case where the operation has no explicit result types.
   if (resultTypes.empty()) {
     // If we don't know the concrete operation, don't attempt any verification.
     // We can't make assumptions if we don't know the concrete operation.
-    Optional<StringRef> rawOpName = op.name();
+    Optional<StringRef> rawOpName = op.getOpName();
     if (!rawOpName)
       return success();
     Optional<RegisteredOperationName> opName =
         RegisteredOperationName::lookup(*rawOpName, op.getContext());
     if (!opName)
       return success();
 
     // If no explicit result types were provided, check to see if the operation
for (const auto &it : llvm::enumerate(resultTypes)) {
 
     // If the type operation was defined in the matcher and constrains an
     // operand or the result of an input operation, it can be used.
     auto constrainsInput = [rewriterBlock](Operation *user) {
       return user->getBlock() != rewriterBlock &&
              isa<OperandOp, OperandsOp, OperationOp>(user);
     };
     if (TypeOp typeOp = dyn_cast<TypeOp>(resultTypeOp)) {
-      if (typeOp.type() || llvm::any_of(typeOp->getUsers(), constrainsInput))
+      if (typeOp.getConstantType() ||
+          llvm::any_of(typeOp->getUsers(), constrainsInput))
         continue;
     } else if (TypesOp typeOp = dyn_cast<TypesOp>(resultTypeOp)) {
-      if (typeOp.types() || llvm::any_of(typeOp->getUsers(), constrainsInput))
+      if (typeOp.getConstantTypes() ||
+          llvm::any_of(typeOp->getUsers(), constrainsInput))
         continue;
     }
 
     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();
 }
 
 LogicalResult OperationOp::verify() {
   bool isWithinRewrite = isa<RewriteOp>((*this)->getParentOp());
-  if (isWithinRewrite && !name())
+  if (isWithinRewrite && !getOpName())
     return emitOpError("must have an operation name when nested within "
                        "a `pdl.rewrite`");
-  ArrayAttr attributeNames = attributeNamesAttr();
-  auto attributeValues = attributes();
+  ArrayAttr attributeNames = getAttributeValueNamesAttr();
+  auto attributeValues = getAttributeValues();
   if (attributeNames.size() != attributeValues.size()) {
     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 && !mightHaveTypeInference()) {
-    if (failed(verifyResultTypesAreInferrable(*this, types())))
+    if (failed(verifyResultTypesAreInferrable(*this, getTypeValues())))
       return failure();
   }
 
   return verifyHasBindingUse(*this);
 }
 
 bool OperationOp::hasTypeInference() {
-  if (Optional<StringRef> rawOpName = name()) {
+  if (Optional<StringRef> rawOpName = getOpName()) {
     OperationName opName(*rawOpName, getContext());
     return opName.hasInterface<InferTypeOpInterface>();
   }
   return false;
 }
 
 bool OperationOp::mightHaveTypeInference() {
-  if (Optional<StringRef> rawOpName = name()) {
+  if (Optional<StringRef> rawOpName = getOpName()) {
     OperationName opName(*rawOpName, getContext());
     return opName.mightHaveInterface<InferTypeOpInterface>();
   }
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
void PatternOp::build(OpBuilder &builder, OperationState &state,
                       Optional<uint16_t> benefit, Optional<StringRef> name) {
   build(builder, state, builder.getI16IntegerAttr(benefit ? *benefit : 0),
         name ? builder.getStringAttr(*name) : StringAttr());
   state.regions[0]->emplaceBlock();
 }
 
 /// Returns the rewrite operation of this pattern.
 RewriteOp PatternOp::getRewriter() {
-  return cast<RewriteOp>(body().front().getTerminator());
+  return cast<RewriteOp>(getBodyRegion().front().getTerminator());
 }
 
 /// The default dialect is `pdl`.
 StringRef PatternOp::getDefaultDialect() {
   return PDLDialect::getDialectNamespace();
 }
 
 //===----------------------------------------------------------------------===//
LogicalResult ResultsOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult RewriteOp::verifyRegions() {
-  Region &rewriteRegion = body();
+  Region &rewriteRegion = getBodyRegion();
 
   // Handle the case where the rewrite is external.
   if (name()) {
     if (!rewriteRegion.empty()) {
       return emitOpError()
              << "expected rewrite region to be empty when rewrite is external";
     }
     return success();
StringRef RewriteOp::getDefaultDialect() {
   return PDLDialect::getDialectNamespace();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult TypeOp::verify() {
-  if (!typeAttr())
+  if (!getConstantTypeAttr())
     return verifyHasBindingUse(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult TypesOp::verify() {
-  if (!typesAttr())
+  if (!getConstantTypesAttr())
     return verifyHasBindingUse(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

 /// operation and update the builder to nest under it. This is necessary for
 /// PDLL operation rewrite statements that are directly nested within a Pattern.
 static void checkAndNestUnderRewriteOp(OpBuilder &builder, Value rootExpr,
                                        Location loc) {
   if (isa<pdl::PatternOp>(builder.getInsertionBlock()->getParentOp())) {
     pdl::RewriteOp rewrite =
         builder.create<pdl::RewriteOp>(loc, rootExpr, /*name=*/StringAttr(),
                                        /*externalArgs=*/ValueRange());
-    builder.createBlock(&rewrite.body());
+    builder.createBlock(&rewrite.getBodyRegion());
   }
 }
 
 void CodeGen::genImpl(const ast::EraseStmt *stmt) {
   OpBuilder::InsertionGuard insertGuard(builder);
   Value rootExpr = genSingleExpr(stmt->getRootOpExpr());
   Location loc = genLoc(stmt->getLoc());
 

mlir/python/mlir/dialects/_pdl_ops_ext.py

def __init__(self,
     args = _get_values(args)
     super().__init__(results, name, args, loc=loc, ip=ip)
 
 
 class AttributeOp:
   """Specialization for PDL attribute op class."""
 
   def __init__(self,
-               type: Optional[Union[OpView, Operation, Value]] = None,
+               valueType: Optional[Union[OpView, Operation, Value]] = None,
                value: Optional[Attribute] = None,
                *,
                loc=None,
                ip=None):
-    type = type if type is None else _get_value(type)
+    valueType = valueType if valueType is None else _get_value(valueType)
     result = pdl.AttributeType.get()
-    super().__init__(result, type=type, value=value, loc=loc, ip=ip)
+    super().__init__(result, valueType=valueType, value=value, loc=loc, ip=ip)
 
 
 class EraseOp:
   """Specialization for PDL erase op class."""
 
   def __init__(self,
                operation: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     operation = _get_value(operation)
     super().__init__(operation, loc=loc, ip=ip)
 
 
 class OperandOp:
   """Specialization for PDL operand op class."""
 
   def __init__(self,
                type: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     type = type if type is None else _get_value(type)
     result = pdl.ValueType.get()
-    super().__init__(result, type=type, loc=loc, ip=ip)
+    super().__init__(result, valueType=type, loc=loc, ip=ip)
 
 
 class OperandsOp:
   """Specialization for PDL operands op class."""
 
   def __init__(self,
                types: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     types = types if types is None else _get_value(types)
     result = pdl.RangeType.get(pdl.ValueType.get())
-    super().__init__(result, type=types, loc=loc, ip=ip)
+    super().__init__(result, valueType=types, loc=loc, ip=ip)
 
 
 class OperationOp:
   """Specialization for PDL operand op class."""
 
   def __init__(self,
                name: Optional[Union[str, StringAttr]] = None,
                args: Sequence[Union[OpView, Operation, Value]] = [],
                attributes: Mapping[str, Union[OpView, Operation, Value]] = {},
                types: Sequence[Union[OpView, Operation, Value]] = [],
                *,
                loc=None,
                ip=None):
     name = name if name is None else _get_str_attr(name)
     args = _get_values(args)
-    attributeNames = []
-    attributeValues = []
+    attrNames = []
+    attrValues = []
     for attrName, attrValue in attributes.items():
-      attributeNames.append(StringAttr.get(attrName))
-      attributeValues.append(_get_value(attrValue))
-    attributeNames = ArrayAttr.get(attributeNames)
+      attrNames.append(StringAttr.get(attrName))
+      attrValues.append(_get_value(attrValue))
+    attrNames = ArrayAttr.get(attrNames)
     types = _get_values(types)
     result = pdl.OperationType.get()
-    super().__init__(result, args, attributeValues, attributeNames, types, name=name, loc=loc, ip=ip)
+    super().__init__(result, args, attrValues, attrNames, types, opName=name, loc=loc, ip=ip)
 
 
 class PatternOp:
   """Specialization for PDL pattern op class."""
 
   def __init__(self,
                benefit: Union[IntegerAttr, int],
                name: Optional[Union[StringAttr, str]] = None,
def body(self):
     """Return the body (block) of the rewrite."""
     return self.regions[0].blocks[0]
 
 
 class TypeOp:
   """Specialization for PDL type op class."""
 
   def __init__(self,
-               type: Optional[Union[TypeAttr, Type]] = None,
+               constantType: Optional[Union[TypeAttr, Type]] = None,
                *,
                loc=None,
                ip=None):
-    type = type if type is None else _get_type_attr(type)
+    constantType = constantType if constantType is None else _get_type_attr(
+        constantType)
     result = pdl.TypeType.get()
-    super().__init__(result, type=type, loc=loc, ip=ip)
+    super().__init__(result, constantType=constantType, loc=loc, ip=ip)
 
 
 class TypesOp:
   """Specialization for PDL types op class."""
 
   def __init__(self,
-               types: Sequence[Union[TypeAttr, Type]] = [],
+               constantTypes: Sequence[Union[TypeAttr, Type]] = [],
                *,
                loc=None,
                ip=None):
-    types = _get_array_attr([_get_type_attr(ty) for ty in types])
-    types = None if not types else types
+    constantTypes = _get_array_attr(
+        [_get_type_attr(ty) for ty in constantTypes])
+    constantTypes = None if not constantTypes else constantTypes
     result = pdl.RangeType.get(pdl.TypeType.get())
-    super().__init__(result, types=types, loc=loc, ip=ip)
+    super().__init__(result, constantTypes=constantTypes, loc=loc, ip=ip)

mlir/test/Dialect/PDL/invalid.mlir

pdl.pattern : benefit(1) {
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected the same number of attribute values and attribute names, got 1 names and 0 values}}
   %op = "pdl.operation"() {
-    attributeNames = ["attr"],
+    attributeValueNames = ["attr"],
     operand_segment_sizes = array<i32: 0, 0, 0>
   } : () -> (!pdl.operation)
   rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {