[mlir] Expand prefixing to OpFormatGen

[jpienaar]

Summary

Follow up to also use the prefixed emitters in OpFormatGen (moved
getGetterName(s) and getSetterName(s) to Operator as that is most
convenient usage wise even though it just depends on Dialect). Prefix
accessors in Test dialect and follow up on missed changes in
OpDefinitionsGen.

[rriddle]

mlir/lib/TableGen/Operator.cpp

674–675

Debugging?

676

Can you add a parameter comment for the true here?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2490–2492

mlir/include/mlir/TableGen/Operator.h

public:
   };
 
   // Returns the OperandOrAttribute corresponding to the index.
   OperandOrAttribute getArgToOperandOrAttribute(int index) const;
 
   // Returns the builders of this operation.
   ArrayRef<Builder> getBuilders() const { return builders; }
 
+  // Returns the preferred getter name for the accessor.
+  std::string getGetterName(StringRef name) const {
+    return getGetterNames(name).front();
+  }
+
+  // Returns the getter names for the accessor.
+  SmallVector<std::string, 2> getGetterNames(StringRef name) const;
+
+  // Returns the setter names for the accessor.
+  SmallVector<std::string, 2> getSetterNames(StringRef name) const;
+
 private:
   // Populates the vectors containing operands, attributes, results and traits.
   void populateOpStructure();
 
   // Populates type inference info (mostly equality) with input a mapping from
   // names to indices for arguments and results.
   void populateTypeInferenceInfo(
       const llvm::StringMap<int> &argumentsAndResultsIndex);

mlir/lib/TableGen/Operator.cpp

 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-operator"
 
 using namespace mlir;
 using namespace mlir::tblgen;
auto Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
     -> VariableDecorator {
   return VariableDecorator(cast<llvm::DefInit>(init)->getDef());
 }
 
 auto Operator::getArgToOperandOrAttribute(int index) const
     -> OperandOrAttribute {
   return attrOrOperandMapping[index];
 }
+
+// Helper to return the names for accessor.
+static SmallVector<std::string, 2>
+getGetterOrSetterNames(bool isGetter, const Operator &op, StringRef name) {
+  Dialect::EmitPrefix prefixType = op.getDialect().getEmitAccessorPrefix();
+  std::string prefix;
+  if (prefixType != Dialect::EmitPrefix::Raw)
+    prefix = isGetter ? "get" : "set";
+
+  SmallVector<std::string, 2> names;
+  bool rawToo = prefixType == Dialect::EmitPrefix::Both;
+
+  auto skip = [&](StringRef newName) {
+    bool shouldSkip = newName == "getOperands";
+    if (!shouldSkip)
+      return false;
+
+    // This note could be avoided where the final function generated would
+    // have been identical. But preferably in the op definition avoiding using
+    // the generic name and then getting a more specialize type is better.
+    PrintNote(op.getLoc(),
+              "Skipping generation of prefixed accessor `" + newName +
+                  "` as it overlaps with default one; generating raw form (`" +
+                  name + "`) still");
+    return true;
+  };
+
+  if (!prefix.empty()) {
+    if (name.startswith(prefix))
+      llvm::report_fatal_error("done");
+    names.push_back(prefix + convertToCamelFromSnakeCase(name, true));
+    // Skip cases which would overlap with default ones for now.
+    if (skip(names.back())) {
+      rawToo = true;
+      names.clear();
+    } else {
+      LLVM_DEBUG(llvm::errs() << "WITH_GETTER(\"" << op.getQualCppClassName()
+                              << "::" << names.back() << "\");\n"
+                              << "WITH_GETTER(\"" << op.getQualCppClassName()
+                              << "Adaptor::" << names.back() << "\");\n";);
+    }
+  }
+
+  if (prefix.empty() || rawToo)
+    names.push_back(name.str());
+  return names;
+}
+
+SmallVector<std::string, 2> Operator::getGetterNames(StringRef name) const {
+  return getGetterOrSetterNames(/*isGetter=*/true, *this, name);
+}
+
+SmallVector<std::string, 2> Operator::getSetterNames(StringRef name) const {
+  return getGetterOrSetterNames(/*isGetter=*/false, *this, name);
+}

mlir/test/lib/Dialect/Test/TestDialect.cpp

 
 //===----------------------------------------------------------------------===//
 // TestBranchOp
 //===----------------------------------------------------------------------===//
 
 Optional<MutableOperandRange>
 TestBranchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index == 0 && "invalid successor index");
-  return targetOperandsMutable();
+  return getTargetOperandsMutable();
 }
 
 //===----------------------------------------------------------------------===//
 // TestDialectCanonicalizerOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
 dialectCanonicalizationPattern(TestDialectCanonicalizerOp op,

 //===----------------------------------------------------------------------===//
 
 namespace {
 struct FoldToCallOpPattern : public OpRewritePattern<FoldToCallOp> {
   using OpRewritePattern<FoldToCallOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(FoldToCallOp op,
                                 PatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), op.calleeAttr(),
+    rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), op.getCalleeAttr(),
                                         ValueRange());
     return success();
   }
 };
 } // end anonymous namespace
 
 void FoldToCallOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
static ParseResult parseIsolatedRegionOp(OpAsmParser &parser,
   Region *body = result.addRegion();
   return parser.parseRegion(*body, argInfo, argType,
                             /*enableNameShadowing=*/true);
 }
 
 static void print(OpAsmPrinter &p, IsolatedRegionOp op) {
   p << "test.isolated_region ";
   p.printOperand(op.getOperand());
-  p.shadowRegionArgs(op.region(), op.getOperand());
-  p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
+  p.shadowRegionArgs(op.getRegion(), op.getOperand());
+  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // Test SSACFGRegionOp
 //===----------------------------------------------------------------------===//
 
 RegionKind SSACFGRegionOp::getRegionKind(unsigned index) {
   return RegionKind::SSACFG;
 }
 
 //===----------------------------------------------------------------------===//
 // Test GraphRegionOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseGraphRegionOp(OpAsmParser &parser,
                                       OperationState &result) {
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{});
 }
 
 static void print(OpAsmPrinter &p, GraphRegionOp op) {
   p << "test.graph_region ";
-  p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
+  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 RegionKind GraphRegionOp::getRegionKind(unsigned index) {
   return RegionKind::Graph;
 }
 
 //===----------------------------------------------------------------------===//
 // Test AffineScopeOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseAffineScopeOp(OpAsmParser &parser,
                                       OperationState &result) {
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{});
 }
 
 static void print(OpAsmPrinter &p, AffineScopeOp op) {
   p << "test.affine_scope ";
-  p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
+  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // Test parser.
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseParseIntegerLiteralOp(OpAsmParser &parser,
                                               OperationState &result) {
static ParseResult parseParseWrappedKeywordOp(OpAsmParser &parser,
   StringRef keyword;
   if (parser.parseKeyword(&keyword))
     return failure();
   result.addAttribute("keyword", parser.getBuilder().getStringAttr(keyword));
   return success();
 }
 
 static void print(OpAsmPrinter &p, ParseWrappedKeywordOp op) {
-  p << " " << op.keyword();
+  p << " " << op.getKeyword();
 }
 
 //===----------------------------------------------------------------------===//
 // Test WrapRegionOp - wrapping op exercising `parseGenericOperation()`.
 
 static ParseResult parseWrappingRegionOp(OpAsmParser &parser,
                                          OperationState &result) {
   if (parser.parseKeyword("wraps"))
static ParseResult parseWrappingRegionOp(OpAsmParser &parser,
   // Use the location of the wrapped op for the "test.wrapping_region" op.
   result.location = wrapped_op->getLoc();
 
   return success();
 }
 
 static void print(OpAsmPrinter &p, WrappingRegionOp op) {
   p << " wraps ";
-  p.printGenericOp(&op.region().front().front());
+  p.printGenericOp(&op.getRegion().front().front());
 }
 
 //===----------------------------------------------------------------------===//
 // Test PolyForOp - parse list of region arguments.
 //===----------------------------------------------------------------------===//
 
 static ParseResult parsePolyForOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 4> ivsInfo;

 } // end anonymous namespace
 
 void TestOpWithRegionPattern::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<TestRemoveOpWithInnerOps>(context);
 }
 
 OpFoldResult TestOpWithRegionFold::fold(ArrayRef<Attribute> operands) {
-  return operand();
+  return getOperand();
 }
 
 OpFoldResult TestOpConstant::fold(ArrayRef<Attribute> operands) {
   return getValue();
 }
 
 LogicalResult TestOpWithVariadicResultsAndFolder::fold(
     ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results) {
static ParseResult parseStringAttrPrettyNameOp(OpAsmParser &parser,
   result.attributes.push_back({Identifier::get("names", context), namesAttr});
   return success();
 }
 
 static void print(OpAsmPrinter &p, StringAttrPrettyNameOp op) {
   // Note that we only need to print the "name" attribute if the asmprinter
   // result name disagrees with it.  This can happen in strange cases, e.g.
   // when there are conflicts.
-  bool namesDisagree = op.names().size() != op.getNumResults();
+  bool namesDisagree = op.getNames().size() != op.getNumResults();
 
   SmallString<32> resultNameStr;
   for (size_t i = 0, e = op.getNumResults(); i != e && !namesDisagree; ++i) {
     resultNameStr.clear();
     llvm::raw_svector_ostream tmpStream(resultNameStr);
     p.printOperand(op.getResult(i), tmpStream);
 
-    auto expectedName = op.names()[i].dyn_cast<StringAttr>();
+    auto expectedName = op.getNames()[i].dyn_cast<StringAttr>();
     if (!expectedName ||
         tmpStream.str().drop_front() != expectedName.getValue()) {
       namesDisagree = true;
     }
   }
 
   if (namesDisagree)
     p.printOptionalAttrDictWithKeyword(op->getAttrs());
   else
     p.printOptionalAttrDictWithKeyword(op->getAttrs(), {"names"});
 }
 
 // We set the SSA name in the asm syntax to the contents of the name
 // attribute.
 void StringAttrPrettyNameOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
 
-  auto value = names();
+  auto value = getNames();
   for (size_t i = 0, e = value.size(); i != e; ++i)
     if (auto str = value[i].dyn_cast<StringAttr>())
       if (!str.getValue().empty())
         setNameFn(getResult(i), str.getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // RegionIfOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, RegionIfOp op) {
   p << " ";
   p.printOperands(op.getOperands());
   p << ": " << op.getOperandTypes();
   p.printArrowTypeList(op.getResultTypes());
   p << " then";
-  p.printRegion(op.thenRegion(),
+  p.printRegion(op.getThenRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
   p << " else";
-  p.printRegion(op.elseRegion(),
+  p.printRegion(op.getElseRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
   p << " join";
-  p.printRegion(op.joinRegion(),
+  p.printRegion(op.getJoinRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
 }
 
 static ParseResult parseRegionIfOp(OpAsmParser &parser,
                                    OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> operandInfos;
   SmallVector<Type, 2> operandTypes;

 }
 
 void RegionIfOp::getSuccessorRegions(
     Optional<unsigned> index, ArrayRef<Attribute> operands,
     SmallVectorImpl<RegionSuccessor> &regions) {
   // We always branch to the join region.
   if (index.hasValue()) {
     if (index.getValue() < 2)
-      regions.push_back(RegionSuccessor(&joinRegion(), getJoinArgs()));
+      regions.push_back(RegionSuccessor(&getJoinRegion(), getJoinArgs()));
     else
       regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
   // The then and else regions are the entry regions of this op.
-  regions.push_back(RegionSuccessor(&thenRegion(), getThenArgs()));
-  regions.push_back(RegionSuccessor(&elseRegion(), getElseArgs()));
+  regions.push_back(RegionSuccessor(&getThenRegion(), getThenArgs()));
+  regions.push_back(RegionSuccessor(&getElseRegion(), getElseArgs()));
 }
 
 //===----------------------------------------------------------------------===//
 // SingleNoTerminatorCustomAsmOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseSingleNoTerminatorCustomAsmOp(OpAsmParser &parser,
                                                       OperationState &state) {

mlir/test/lib/Dialect/Test/TestOps.td

 include "mlir/Dialect/Linalg/IR/LinalgInterfaces.td"
 include "TestInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "::test";
   // Temporarily flipping to _Both (given this is test only/not intended for
   // general use, this won't be following the 2 week process here).
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationInterfaceFallback = 1;
   let hasNonDefaultDestructor = 1;
   let dependentDialects = ["::mlir::DLTIDialect"];
let arguments = (ins
       RankedI32ElementsAttr<[2]>:$vector_i32_attr,
       RankedI64ElementsAttr<[4, 8]>:$matrix_i64_attr
   );
 }
 
 def DerivedTypeAttrOp : TEST_Op<"derived_type_attr", []> {
   let results = (outs AnyTensor:$output);
   DerivedTypeAttr element_dtype =
-    DerivedTypeAttr<"return getElementTypeOrSelf(output().getType());">;
+    DerivedTypeAttr<"return getElementTypeOrSelf(getOutput().getType());">;
   DerivedAttr size = DerivedAttr<"int",
-    "return output().getType().cast<ShapedType>().getSizeInBits();",
+    "return getOutput().getType().cast<ShapedType>().getSizeInBits();",
     "$_builder.getI32IntegerAttr($_self)">;
 }
 
 def StringElementsAttrOp : TEST_Op<"string_elements_attr"> {
   let arguments = (ins
       StringElementsAttr:$scalar_string_attr
   );
 }

 }
 
 //===----------------------------------------------------------------------===//
 // Test Call Interfaces
 //===----------------------------------------------------------------------===//
 
 def ConversionCallOp : TEST_Op<"conversion_call_op",
     [CallOpInterface]> {
-  let arguments = (ins Variadic<AnyType>:$inputs, SymbolRefAttr:$callee);
+  let arguments = (ins Variadic<AnyType>:$arg_operands, SymbolRefAttr:$callee);
   let results = (outs Variadic<AnyType>);
 
   let extraClassDeclaration = [{
-    /// Get the argument operands to the called function.
-    operand_range getArgOperands() { return inputs(); }
-
     /// Return the callee of this operation.
     ::mlir::CallInterfaceCallable getCallableForCallee() {
       return (*this)->getAttrOfType<::mlir::SymbolRefAttr>("callee");
     }
   }];
 }
 
 def FunctionalRegionOp : TEST_Op<"functional_region_op",
     [CallableOpInterface]> {
   let regions = (region AnyRegion:$body);
   let results = (outs FunctionType);
 
   let extraClassDeclaration = [{
-    ::mlir::Region *getCallableRegion() { return &body(); }
+    ::mlir::Region *getCallableRegion() { return &getBody(); }
     ::llvm::ArrayRef<::mlir::Type> getCallableResults() {
       return getType().cast<::mlir::FunctionType>().getResults();
     }
   }];
 }
 
 
 def FoldToCallOp : TEST_Op<"fold_to_call_op"> {

 }
 
 // This operation requires its "attr" attribute to have the
 // trait 'TestAttrTrait'.
 def AttrWithTraitOp : TEST_Op<"attr_with_trait", []> {
   let arguments = (ins AnyAttr:$attr);
 
   let verifier = [{
-    if (this->attr().hasTrait<AttributeTrait::TestAttrTrait>())
+    if (this->getAttr().hasTrait<AttributeTrait::TestAttrTrait>())
       return success();
     return this->emitError("'attr' attribute should have trait 'TestAttrTrait'");
   }];
 }
 
 
 //===----------------------------------------------------------------------===//
 // Test Locations
let extraClassDeclaration = [{
 
     mlir::ArrayAttr indexing_maps() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
     }
 
     std::string getLibraryCallName() {
       return "";
     }
+
+    // To conform with interface requirement on operand naming.
+    mlir::ValueRange inputs() { return getInputs(); }
+    mlir::ValueRange outputs() { return getOutputs(); }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test Ops with Default-Valued String Attributes
 //===----------------------------------------------------------------------===//
 
 def TestDefaultStrAttrNoValueOp : TEST_Op<"no_str_value"> {

mlir/test/lib/Dialect/Test/TestPatterns.cpp

 
 static void createOpI(PatternRewriter &rewriter, Location loc, Value input) {
   rewriter.create<OpI>(loc, input);
 }
 
 static void handleNoResultOp(PatternRewriter &rewriter,
                              OpSymbolBindingNoResult op) {
   // Turn the no result op to a one-result op.
-  rewriter.create<OpSymbolBindingB>(op.getLoc(), op.operand().getType(),
-                                    op.operand());
+  rewriter.create<OpSymbolBindingB>(op.getLoc(), op.getOperand().getType(),
+                                    op.getOperand());
 }
 
 static bool getFirstI32Result(Operation *op, Value &value) {
   if (!Type(op->getResult(0).getType()).isSignlessInteger(32))
     return false;
   value = op->getResult(0);
   return true;
 }
void initialize() {
     // The conversion target handles bounding the recursion of this pattern.
     setHasBoundedRewriteRecursion();
   }
 
   LogicalResult matchAndRewrite(TestRecursiveRewriteOp op,
                                 PatternRewriter &rewriter) const final {
     // Decrement the depth of the op in-place.
     rewriter.updateRootInPlace(op, [&] {
-      op->setAttr("depth", rewriter.getI64IntegerAttr(op.depth() - 1));
+      op->setAttr("depth", rewriter.getI64IntegerAttr(op.getDepth() - 1));
     });
     return success();
   }
 };
 
 struct TestNestedOpCreationUndoRewrite
     : public OpRewritePattern<IllegalOpWithRegionAnchor> {
   using OpRewritePattern<IllegalOpWithRegionAnchor>::OpRewritePattern;
void runOnOperation() override {
     // Check support for marking certain operations as recursively legal.
     target.markOpRecursivelyLegal<FuncOp, ModuleOp>([](Operation *op) {
       return static_cast<bool>(
           op->getAttrOfType<UnitAttr>("test.recursively_legal"));
     });
 
     // Mark the bound recursion operation as dynamically legal.
     target.addDynamicallyLegalOp<TestRecursiveRewriteOp>(
-        [](TestRecursiveRewriteOp op) { return op.depth() == 0; });
+        [](TestRecursiveRewriteOp op) { return op.getDepth() == 0; });
 
     // Handle a partial conversion.
     if (mode == ConversionMode::Partial) {
       DenseSet<Operation *> unlegalizedOps;
       if (failed(applyPartialConversion(
               getOperation(), target, std::move(patterns), &unlegalizedOps))) {
         getOperation()->emitRemark() << "applyPartialConversion failed";
       }

 namespace {
 /// A rewriter pattern that tests that blocks can be merged.
 struct TestMergeBlock : public OpConversionPattern<TestMergeBlocksOp> {
   using OpConversionPattern<TestMergeBlocksOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(TestMergeBlocksOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    Block &firstBlock = op.body().front();
+    Block &firstBlock = op.getBody().front();
     Operation *branchOp = firstBlock.getTerminator();
-    Block *secondBlock = &*(std::next(op.body().begin()));
+    Block *secondBlock = &*(std::next(op.getBody().begin()));
     auto succOperands = branchOp->getOperands();
     SmallVector<Value, 2> replacements(succOperands);
     rewriter.eraseOp(branchOp);
     rewriter.mergeBlocks(secondBlock, &firstBlock, replacements);
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
 };
struct TestMergeSingleBlockOps
 
   LogicalResult
   matchAndRewrite(SingleBlockImplicitTerminatorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     SingleBlockImplicitTerminatorOp parentOp =
         op->getParentOfType<SingleBlockImplicitTerminatorOp>();
     if (!parentOp)
       return failure();
-    Block &innerBlock = op.region().front();
+    Block &innerBlock = op.getRegion().front();
     TerminatorOp innerTerminator =
         cast<TerminatorOp>(innerBlock.getTerminator());
     rewriter.mergeBlockBefore(&innerBlock, op);
     rewriter.eraseOp(innerTerminator);
     rewriter.eraseOp(op);
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
void runOnOperation() override {
     ConversionTarget target(*context);
     target.addLegalOp<FuncOp, ModuleOp, TerminatorOp, TestBranchOp,
                       TestTypeConsumerOp, TestTypeProducerOp, TestReturnOp>();
     target.addIllegalOp<ILLegalOpF>();
 
     /// Expect the op to have a single block after legalization.
     target.addDynamicallyLegalOp<TestMergeBlocksOp>(
         [&](TestMergeBlocksOp op) -> bool {
-          return llvm::hasSingleElement(op.body());
+          return llvm::hasSingleElement(op.getBody());
         });
 
     /// Only allow `test.br` within test.merge_blocks op.
     target.addDynamicallyLegalOp<TestBranchOp>([&](TestBranchOp op) -> bool {
       return op->getParentOfType<TestMergeBlocksOp>();
     });
 
     /// Expect that all nested test.SingleBlockImplicitTerminator ops are

mlir/test/lib/Transforms/TestInlining.cpp

for (auto caller : callers) {
       auto callee = dyn_cast_or_null<FunctionalRegionOp>(
           caller.getCallee().getDefiningOp());
       if (!callee)
         continue;
 
       // Inline the functional region operation, but only clone the internal
       // region if there is more than one use.
       if (failed(inlineRegion(
-              interface, &callee.body(), caller, caller.getArgOperands(),
+              interface, &callee.getBody(), caller, caller.getArgOperands(),
               caller.getResults(), caller.getLoc(),
               /*shouldCloneInlinedRegion=*/!callee.getResult().hasOneUse())))
         continue;
 
       // If the inlining was successful then erase the call and callee if
       // possible.
       caller.erase();
       if (callee.use_empty())

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

private:
   // The C++ code builder for this op
   OpClass opClass;
 
   // The format context for verification code generation.
   FmtContext verifyCtx;
 
   // The emitter containing all of the locally emitted verification functions.
   const StaticVerifierFunctionEmitter &staticVerifierEmitter;
-
-  // A map of attribute names (including implicit attributes) registered to the
-  // current operation, to the relative order in which they were registered.
-  llvm::MapVector<StringRef, unsigned> attributeNames;
 };
 } // end anonymous namespace
 
 // Populate the format context `ctx` with substitutions of attributes, operands
 // and results.
 // - attrGet corresponds to the name of the function to call to get value of
 //   attribute (the generated function call returns an Attribute);
 // - operandGet corresponds to the name of the function with which to retrieve
void OpEmitter::emitDef(
     const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
   OpEmitter(op, staticVerifierEmitter).emitDef(os);
 }
 
 void OpEmitter::emitDecl(raw_ostream &os) { opClass.writeDeclTo(os); }
 
 void OpEmitter::emitDef(raw_ostream &os) { opClass.writeDefTo(os); }
 
-// Helper to return the names for accessor.
-static SmallVector<std::string, 2>
-getGetterOrSetterNames(bool isGetter, const Operator &op, StringRef name) {
-  Dialect::EmitPrefix prefixType = op.getDialect().getEmitAccessorPrefix();
-  std::string prefix;
-  if (prefixType != Dialect::EmitPrefix::Raw)
-    prefix = isGetter ? "get" : "set";
-
-  SmallVector<std::string, 2> names;
-  bool rawToo = prefixType == Dialect::EmitPrefix::Both;
-
-  auto skip = [&](StringRef newName) {
-    bool shouldSkip = newName == "getOperands";
-    if (!shouldSkip)
-      return false;
-
-    // This note could be avoided where the final function generated would
-    // have been identical. But preferably in the op definition avoiding using
-    // the generic name and then getting a more specialize type is better.
-    PrintNote(op.getLoc(),
-              "Skipping generation of prefixed accessor `" + newName +
-                  "` as it overlaps with default one; generating raw form (`" +
-                  name + "`) still");
-    return true;
-  };
-
-  if (!prefix.empty()) {
-    names.push_back(prefix + convertToCamelFromSnakeCase(name, true));
-    // Skip cases which would overlap with default ones for now.
-    if (skip(names.back())) {
-      rawToo = true;
-      names.clear();
-    } else {
-      LLVM_DEBUG(llvm::errs() << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "::" << names.back() << "\");\n"
-                              << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "Adaptor::" << names.back() << "\");\n";);
-    }
-  }
-
-  if (prefix.empty() || rawToo)
-    names.push_back(name.str());
-  return names;
-}
-static SmallVector<std::string, 2> getGetterNames(const Operator &op,
-                                                  StringRef name) {
-  return getGetterOrSetterNames(/*isGetter=*/true, op, name);
-}
-static std::string getGetterName(const Operator &op, StringRef name) {
-  return getGetterOrSetterNames(/*isGetter=*/true, op, name).front();
-}
-static SmallVector<std::string, 2> getSetterNames(const Operator &op,
-                                                  StringRef name) {
-  return getGetterOrSetterNames(/*isGetter=*/false, op, name);
-}
-
 static void errorIfPruned(size_t line, OpMethod *m, const Twine &methodName,
                           const Operator &op) {
   if (m)
     return;
   PrintFatalError(op.getLoc(), "Unexpected overlap when generating `" +
                                    methodName + "` for " +
                                    op.getOperationName() + " (from line " +
                                    Twine(line) + ")");
 }
 #define ERROR_IF_PRUNED(M, N, O) errorIfPruned(__LINE__, M, N, O)
 
 void OpEmitter::genAttrNameGetters() {
+  // A map of attribute names (including implicit attributes) registered to the
+  // current operation, to the relative order in which they were registered.
+  llvm::MapVector<StringRef, unsigned> attributeNames;
+
   // Enumerate the attribute names of this op, assigning each a relative
   // ordering.
   auto addAttrName = [&](StringRef name) {
     unsigned index = attributeNames.size();
     attributeNames.insert({name, index});
   };
   for (const NamedAttribute &namedAttr : op.getAttributes())
     addAttrName(namedAttr.name);
   // Include key attributes from several traits as implicitly registered.
+  std::string operandSizes = "operand_segment_sizes";
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
-    addAttrName("operand_segment_sizes");
+    addAttrName(operandSizes);
+  std::string attrSizes = "result_segment_sizes";
   if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
-    addAttrName("result_segment_sizes");
+    addAttrName(attrSizes);
 
   // Emit the getAttributeNames method.
   {
     auto *method = opClass.addMethodAndPrune(
         "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames",
         OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Inline));
     ERROR_IF_PRUNED(method, "getAttributeNames", op);
     auto &body = method->body();
method->body() << "assert(index < " << attributeNames.size()
                       "  return name.getAbstractOperation()"
                       "->getAttributeNames()[index];";
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
   for (const std::pair<StringRef, unsigned> &attrIt : attributeNames) {
-    for (StringRef name : getGetterNames(op, attrIt.first)) {
+    for (StringRef name : op.getGetterNames(attrIt.first)) {
       std::string methodName = (name + "AttrName").str();
 
       // Generate the non-static variant.
       {
         auto *method =
             opClass.addMethodAndPrune("::mlir::Identifier", methodName,
                                       OpMethod::Property(OpMethod::MP_Inline));
         ERROR_IF_PRUNED(method, methodName, op);
auto emitAttrWithStorageType = [&](StringRef name, Attribute attr) {
     if (attr.isOptional() || attr.hasDefaultValue())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
-    for (StringRef name : getGetterNames(op, namedAttr.name)) {
+    for (StringRef name : op.getGetterNames(namedAttr.name)) {
       if (namedAttr.attr.isDerivedAttr()) {
         emitDerivedAttr(name, namedAttr.attr);
       } else {
         emitAttrWithStorageType(name, namedAttr.attr);
         emitAttrWithReturnType(name, namedAttr.attr);
       }
     }
   }
// Generate method to materialize derived attributes as a DictionaryAttr.
 
       auto nonMaterializable =
           make_filter_range(derivedAttrs, [](const NamedAttribute &namedAttr) {
             return namedAttr.attr.getConvertFromStorageCall().empty();
           });
       if (!nonMaterializable.empty()) {
         std::string attrs;
         llvm::raw_string_ostream os(attrs);
-        interleaveComma(nonMaterializable, os,
-                        [&](const NamedAttribute &attr) { os << attr.name; });
+        interleaveComma(nonMaterializable, os, [&](const NamedAttribute &attr) {
+          os << op.getGetterName(attr.name);
+        });
         PrintWarning(
             op.getLoc(),
             formatv(
                 "op has non-materializable derived attributes '{0}', skipping",
                 os.str()));
         body << formatv("  emitOpError(\"op has non-materializable derived "
                         "attributes '{0}'\");\n",
                         attrs);
         body << "  return nullptr;";
         return;
       }
 
       body << "  ::mlir::MLIRContext* ctx = getContext();\n";
       body << "  ::mlir::Builder odsBuilder(ctx); (void)odsBuilder;\n";
       body << "  return ::mlir::DictionaryAttr::get(";
       body << "  ctx, {\n";
       interleave(
           derivedAttrs, body,
           [&](const NamedAttribute &namedAttr) {
             auto tmpl = namedAttr.attr.getConvertFromStorageCall();
-            body << "    {" << namedAttr.name << "AttrName(),\n"
-                 << tgfmt(tmpl, &fctx.withSelf(namedAttr.name + "()")
+            std::string name = op.getGetterName(namedAttr.name);
+            body << "    {" << name << "AttrName(),\n"
+                 << tgfmt(tmpl, &fctx.withSelf(name + "()")
                                      .withBuilder("odsBuilder")
                                      .addSubst("_ctx", "ctx"))
                  << "}";
           },
           ",\n");
       body << "});";
     }
   }
auto *method = opClass.addMethodAndPrune(
         "void", (setterName + "Attr").str(), attr.getStorageType(), "attr");
     if (method)
       method->body() << "  (*this)->setAttr(" << getterName
                      << "AttrName(), attr);";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     if (!namedAttr.attr.isDerivedAttr())
-      for (auto names : llvm::zip(getSetterNames(op, namedAttr.name),
-                                  getGetterNames(op, namedAttr.name)))
+      for (auto names : llvm::zip(op.getSetterNames(namedAttr.name),
+                                  op.getGetterNames(namedAttr.name)))
         emitAttrWithStorageType(std::get<0>(names), std::get<1>(names),
                                 namedAttr.attr);
   }
 }
 
 void OpEmitter::genOptionalAttrRemovers() {
   // Generate methods for removing optional attributes, instead of having to
   // use the string interface. Enables better compile time verification.
   auto emitRemoveAttr = [&](StringRef name) {
     auto upperInitial = name.take_front().upper();
     auto suffix = name.drop_front();
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Attribute", ("remove" + upperInitial + suffix + "Attr").str());
     if (!method)
       return;
-    method->body() << "  return (*this)->removeAttr(" << getGetterName(op, name)
+    method->body() << "  return (*this)->removeAttr(" << op.getGetterName(name)
                    << "AttrName());";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes())
     if (namedAttr.attr.isOptional())
       emitRemoveAttr(namedAttr.name);
 }
 
body << formatv(valueRangeReturnCode, rangeBeginCall,
                   "getODSOperandIndexAndLength(index)");
 
   // Then we emit nicer named getter methods by redirecting to the "sink" getter
   // method.
   for (int i = 0; i != numOperands; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
-    for (StringRef name : getGetterNames(op, operand.name)) {
+    for (StringRef name : op.getGetterNames(operand.name)) {
       if (operand.isOptional()) {
         m = opClass.addMethodAndPrune("::mlir::Value", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << "  auto operands = getODSOperands(" << i << ");\n"
                   << "  return operands.empty() ? ::mlir::Value() : "
                      "*operands.begin();";
       } else if (operand.isVariadicOfVariadic()) {
-        StringRef segmentAttr =
-            operand.constraint.getVariadicOfVariadicSegmentSizeAttr();
+        std::string segmentAttr = op.getGetterName(
+            operand.constraint.getVariadicOfVariadicSegmentSizeAttr());
         if (isAdaptor) {
           m = opClass.addMethodAndPrune(
               "::llvm::SmallVector<::mlir::ValueRange>", name);
           ERROR_IF_PRUNED(m, name, op);
           m->body() << llvm::formatv(variadicOfVariadicAdaptorCalcCode,
                                      segmentAttr, i);
           continue;
         }
for (StringRef name : op.getGetterNames(operand.name)) {
         ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return *getODSOperands(" << i << ").begin();";
       }
     }
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {
-  // Build the code snippet used for initializing the operand_segment_sizes
+  // Build the code snippet used for initializing the operand_segment_size)s
   // array.
   std::string attrSizeInitCode;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-    attrSizeInitCode =
-        formatv(opSegmentSizeAttrInitCode, "operand_segment_sizesAttrName()")
-            .str();
+    std::string attr = op.getGetterName("operand_segment_sizes") + "AttrName()";
+    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
   }
 
   generateNamedOperandGetters(
       op, opClass,
       /*isAdaptor=*/false,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
       /*rangeSizeCall=*/"getOperation()->getNumOperands()",
       /*getOperandCallPattern=*/"getOperation()->getOperand({0})");
 }
 
 void OpEmitter::genNamedOperandSetters() {
   auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
-    for (StringRef name : getGetterNames(op, operand.name)) {
+    for (StringRef name : op.getGetterNames(operand.name)) {
       auto *m = opClass.addMethodAndPrune(
           operand.isVariadicOfVariadic() ? "::mlir::MutableOperandRangeRange"
                                          : "::mlir::MutableOperandRange",
           (name + "Mutable").str());
       ERROR_IF_PRUNED(m, name, op);
       auto &body = m->body();
       body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"
            << "  auto mutableRange = "
               "::mlir::MutableOperandRange(getOperation(), "
               "range.first, range.second";
       if (attrSizedOperands)
         body << ", ::mlir::MutableOperandRange::OperandSegment(" << i
              << "u, *getOperation()->getAttrDictionary().getNamed("
-                "operand_segment_sizesAttrName()))";
+             << op.getGetterName("operand_segment_sizes") << "AttrName()))";
       body << ");\n";
 
       // If this operand is a nested variadic, we split the range into a
       // MutableOperandRangeRange that provides a range over all of the
       // sub-ranges.
       if (operand.isVariadicOfVariadic()) {
         //
         body << "  return "
                 "mutableRange.split(*(*this)->getAttrDictionary().getNamed("
-             << getGetterName(
-                    op,
+             << op.getGetterName(
                     operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
              << "AttrName()));\n";
       } else {
         // Otherwise, we use the full range directly.
         body << "  return mutableRange;\n";
       }
     }
   }
if (attrSizedResults && sameVariadicSize) {
     PrintFatalError(op.getLoc(),
                     "op cannot have both 'AttrSizedResultSegments' and "
                     "'SameVariadicResultSize' traits");
   }
 
   // Build the initializer string for the result segment size attribute.
   std::string attrSizeInitCode;
   if (attrSizedResults) {
-    attrSizeInitCode =
-        formatv(opSegmentSizeAttrInitCode, "result_segment_sizesAttrName()")
-            .str();
+    std::string attr = op.getGetterName("result_segment_sizes") + "AttrName()";
+    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
   }
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       attrSizeInitCode, op.getResults());
 
   auto *m = opClass.addMethodAndPrune("::mlir::Operation::result_range",
                                       "getODSResults", "unsigned", "index");
   ERROR_IF_PRUNED(m, "getODSResults", op);
   m->body() << formatv(valueRangeReturnCode, "getOperation()->result_begin()",
                        "getODSResultIndexAndLength(index)");
 
   for (int i = 0; i != numResults; ++i) {
     const auto &result = op.getResult(i);
     if (result.name.empty())
       continue;
-    for (StringRef name : getGetterNames(op, result.name)) {
+    for (StringRef name : op.getGetterNames(result.name)) {
       if (result.isOptional()) {
         m = opClass.addMethodAndPrune("::mlir::Value", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body()
             << "  auto results = getODSResults(" << i << ");\n"
             << "  return results.empty() ? ::mlir::Value() : *results.begin();";
       } else if (result.isVariadic()) {
         m = opClass.addMethodAndPrune("::mlir::Operation::result_range", name);

 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
-    for (StringRef name : getGetterNames(op, region.name)) {
+    for (StringRef name : op.getGetterNames(region.name)) {
       // Generate the accessors for a variadic region.
       if (region.isVariadic()) {
         auto *m = opClass.addMethodAndPrune(
             "::mlir::MutableArrayRef<::mlir::Region>", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << formatv("  return (*this)->getRegions().drop_front({0});",
                              i);
         continue;
       }
 
       auto *m = opClass.addMethodAndPrune("::mlir::Region &", name);
       ERROR_IF_PRUNED(m, name, op);
       m->body() << formatv("  return (*this)->getRegion({0});", i);
     }
   }
 }
 
 void OpEmitter::genNamedSuccessorGetters() {
   unsigned numSuccessors = op.getNumSuccessors();
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (successor.name.empty())
       continue;
 
-    for (StringRef name : getGetterNames(op, successor.name)) {
+    for (StringRef name : op.getGetterNames(successor.name)) {
       // Generate the accessors for a variadic successor list.
       if (successor.isVariadic()) {
         auto *m = opClass.addMethodAndPrune("::mlir::SuccessorRange", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << formatv(
             "  return {std::next((*this)->successor_begin(), {0}), "
             "(*this)->successor_end()};",
             i);
if (!m)
     return;
 
   auto &body = m->body();
 
   // Push all result types to the operation state
   std::string resultType;
   const auto &namedAttr = op.getAttribute(0);
 
-  body << "  auto attrName = " << getGetterName(op, namedAttr.name)
+  body << "  auto attrName = " << op.getGetterName(namedAttr.name)
        << "AttrName(" << builderOpState
        << ".name);\n"
           "  for (auto attr : attributes) {\n"
           "    if (attr.first != attrName) continue;\n";
   if (namedAttr.attr.isTypeAttr()) {
     resultType = "attr.second.cast<::mlir::TypeAttr>().getValue()";
   } else {
     resultType = "attr.second.getType()";
if (operand.constraint.isVariadicOfVariadic()) {
            << builderOpState << ".addOperands(range);\n";
 
       // Add the segment attribute.
       body << "  {\n"
            << "    SmallVector<int32_t> rangeSegments;\n"
            << "    for (::mlir::ValueRange range : " << argName << ")\n"
            << "      rangeSegments.push_back(range.size());\n"
            << "    " << builderOpState << ".addAttribute("
-           << getGetterName(
-                  op, operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
+           << op.getGetterName(
+                  operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
            << "AttrName(" << builderOpState << ".name), " << odsBuilder
            << ".getI32TensorAttr(rangeSegments));"
            << "  }\n";
       continue;
     }
 
     if (operand.isOptional())
       body << "  if (" << argName << ")\n  ";
     body << "  " << builderOpState << ".addOperands(" << argName << ");\n";
   }
 
   // If the operation has the operand segment size attribute, add it here.
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-    body << "  " << builderOpState
-         << ".addAttribute(operand_segment_sizesAttrName(" << builderOpState
-         << ".name), "
+    std::string sizes = op.getGetterName("operand_segment_sizes");
+    body << "  " << builderOpState << ".addAttribute(" << sizes << "AttrName("
+         << builderOpState << ".name), "
          << "odsBuilder.getI32VectorAttr({";
     interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
       const NamedTypeConstraint &operand = op.getOperand(i);
       if (!operand.isVariableLength()) {
         body << "1";
         return;
       }
 
if (isRawValueAttr && canUseUnwrappedRawValue(attr)) {
       // here given we use function arguments. So we need to strip the
       // wrapping quotes.
       if (StringRef(builderTemplate).contains("\"$0\""))
         builderTemplate = replaceAllSubstrs(builderTemplate, "\"$0\"", "$0");
 
       std::string value =
           std::string(tgfmt(builderTemplate, &fctx, namedAttr.name));
       body << formatv("  {0}.addAttribute({1}AttrName({0}.name), {2});\n",
-                      builderOpState, getGetterName(op, namedAttr.name), value);
+                      builderOpState, op.getGetterName(namedAttr.name), value);
     } else {
       body << formatv("  {0}.addAttribute({1}AttrName({0}.name), {2});\n",
-                      builderOpState, getGetterName(op, namedAttr.name),
+                      builderOpState, op.getGetterName(namedAttr.name),
                       namedAttr.name);
     }
     if (emitNotNullCheck)
       body << "  }\n";
   }
 
   // Create the correct number of regions.
   for (const NamedRegion &region : op.getRegions()) {
for (unsigned i = 0; i < numRegions; ++i) {
     if (region.constraint.getPredicate().isNull())
       continue;
 
     body << "    for (::mlir::Region &region : ";
     body << formatv(region.isVariadic()
                         ? "{0}()"
                         : "::mlir::MutableArrayRef<::mlir::Region>((*this)"
                           "->getRegion({1}))",
-                    region.name, i);
+                    op.getGetterName(region.name), i);
     body << ") {\n";
     auto constraint = tgfmt(region.constraint.getConditionTemplate(),
                             &verifyCtx.withSelf("region"))
                           .str();
 
     body << formatv("      (void)region;\n"
                     "      if (!({0})) {\n        "
                     "return emitOpError(\"region #\") << index << \" {1}"
const auto *attrSizedOperands =
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
   }
 
   {
     auto *m = adaptor.addMethodAndPrune("::mlir::ValueRange", "getOperands");
     ERROR_IF_PRUNED(m, "getOperands", op);
     m->body() << "  return odsOperands;";
   }
-  std::string sizeAttrInit =
-      formatv(adapterSegmentSizeAttrInitCode, "operand_segment_sizes");
+  std::string attr = op.getGetterName("operand_segment_sizes");
+  std::string sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode, attr);
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
auto emitAttr = [&](StringRef name, Attribute attr) {
     auto *m =
         adaptor.addMethodAndPrune("::mlir::DictionaryAttr", "getAttributes");
     ERROR_IF_PRUNED(m, "Adaptor::getAttributes", op);
     m->body() << "  return odsAttrs;";
   }
   for (auto &namedAttr : op.getAttributes()) {
     const auto &name = namedAttr.name;
     const auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr())
-      emitAttr(name, attr);
+      for (auto emitName : op.getGetterNames(name))
+        emitAttr(emitName, attr);
   }
 
   unsigned numRegions = op.getNumRegions();
   if (numRegions > 0) {
     auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", "getRegions");
     ERROR_IF_PRUNED(m, "Adaptor::getRegions", op);
     m->body() << "  return odsRegions;";
   }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

body << (StringRef)StringSwitch<StringRef>(value)
               .Case("[", "LSquare()")
               .Case("]", "RSquare()")
               .Case("?", "Question()")
               .Case("+", "Plus()")
               .Case("*", "Star()");
 }
 
 /// Generate the storage code required for parsing the given element.
-static void genElementParserStorage(Element *element, OpMethodBody &body) {
+static void genElementParserStorage(Element *element, const Operator &op,
+                                    OpMethodBody &body) {
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     auto elements = optional->getThenElements();
 
     // If the anchor is a unit attribute, it won't be parsed directly so elide
     // it.
     auto *anchor = dyn_cast<AttributeVariable>(optional->getAnchor());
     Element *elidedAnchorElement = nullptr;
     if (anchor && anchor != &*elements.begin() && anchor->isUnitAttr())
       elidedAnchorElement = anchor;
     for (auto &childElement : elements)
       if (&childElement != elidedAnchorElement)
-        genElementParserStorage(&childElement, body);
+        genElementParserStorage(&childElement, op, body);
     for (auto &childElement : optional->getElseElements())
-      genElementParserStorage(&childElement, body);
+      genElementParserStorage(&childElement, op, body);
 
   } else if (auto *custom = dyn_cast<CustomDirective>(element)) {
     for (auto &paramElement : custom->getArguments())
-      genElementParserStorage(&paramElement, body);
+      genElementParserStorage(&paramElement, op, body);
 
   } else if (isa<OperandsDirective>(element)) {
     body << "  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> "
             "allOperands;\n";
 
   } else if (isa<RegionsDirective>(element)) {
     body << "  ::llvm::SmallVector<std::unique_ptr<::mlir::Region>, 2> "
             "fullRegions;\n";
auto *method =
       opClass.addMethodAndPrune("::mlir::ParseResult", "parse",
                                 OpMethod::MP_Static, std::move(paramList));
   auto &body = method->body();
 
   // Generate variables to store the operands and type within the format. This
   // allows for referencing these variables in the presence of optional
   // groupings.
   for (auto &element : elements)
-    genElementParserStorage(&*element, body);
+    genElementParserStorage(&*element, op, body);
 
   // A format context used when parsing attributes with buildable types.
   FmtContext attrTypeCtx;
   attrTypeCtx.withBuilder("parser.getBuilder()");
 
   // Generate parsers for each of the elements.
   for (auto &element : elements)
     genElementParser(element.get(), body, attrTypeCtx);
static void genSpacePrinter(bool value, OpMethodBody &body,
   } else {
     lastWasPunctuation = true;
   }
   shouldEmitSpace = false;
 }
 
 /// Generate the printer for a custom directive parameter.
 static void genCustomDirectiveParameterPrinter(Element *element,
+                                               const Operator &op,
                                                OpMethodBody &body) {
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
-    body << attr->getVar()->name << "Attr()";
+    body << op.getGetterName(attr->getVar()->name) << "Attr()";
 
   } else if (isa<AttrDictDirective>(element)) {
     body << "getOperation()->getAttrDictionary()";
 
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
-    body << operand->getVar()->name << "()";
+    body << op.getGetterName(operand->getVar()->name) << "()";
 
   } else if (auto *region = dyn_cast<RegionVariable>(element)) {
-    body << region->getVar()->name << "()";
+    body << op.getGetterName(region->getVar()->name) << "()";
 
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
-    body << successor->getVar()->name << "()";
+    body << op.getGetterName(successor->getVar()->name) << "()";
 
   } else if (auto *dir = dyn_cast<RefDirective>(element)) {
-    genCustomDirectiveParameterPrinter(dir->getOperand(), body);
+    genCustomDirectiveParameterPrinter(dir->getOperand(), op, body);
 
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     auto *typeOperand = dir->getOperand();
     auto *operand = dyn_cast<OperandVariable>(typeOperand);
     auto *var = operand ? operand->getVar()
                         : cast<ResultVariable>(typeOperand)->getVar();
+    std::string name = op.getGetterName(var->name);
     if (var->isVariadic())
-      body << var->name << "().getTypes()";
+      body << name << "().getTypes()";
     else if (var->isOptional())
-      body << llvm::formatv("({0}() ? {0}().getType() : Type())", var->name);
+      body << llvm::formatv("({0}() ? {0}().getType() : Type())", name);
     else
-      body << var->name << "().getType()";
+      body << name << "().getType()";
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the printer for a custom directive.
 static void genCustomDirectivePrinter(CustomDirective *customDir,
-                                      OpMethodBody &body) {
+                                      const Operator &op, OpMethodBody &body) {
   body << "  print" << customDir->getName() << "(p, *this";
   for (Element &param : customDir->getArguments()) {
     body << ", ";
-    genCustomDirectiveParameterPrinter(&param, body);
+    genCustomDirectiveParameterPrinter(&param, op, body);
   }
   body << ");\n";
 }
 
 /// Generate the printer for a region with the given variable name.
 static void genRegionPrinter(const Twine &regionName, OpMethodBody &body,
                              bool hasImplicitTermTrait) {
   if (hasImplicitTermTrait)
     body << llvm::formatv(regionSingleBlockImplicitTerminatorPrinterCode,
                           regionName);
   else
     body << "  p.printRegion(" << regionName << ");\n";
 }
 static void genVariadicRegionPrinter(const Twine &regionListName,
                                      OpMethodBody &body,
                                      bool hasImplicitTermTrait) {
   body << "    llvm::interleaveComma(" << regionListName
        << ", p, [&](::mlir::Region &region) {\n      ";
   genRegionPrinter("region", body, hasImplicitTermTrait);
   body << "    });\n";
 }
 
 /// Generate the C++ for an operand to a (*-)type directive.
-static OpMethodBody &genTypeOperandPrinter(Element *arg, OpMethodBody &body) {
+static OpMethodBody &genTypeOperandPrinter(Element *arg, const Operator &op,
+                                           OpMethodBody &body) {
   if (isa<OperandsDirective>(arg))
     return body << "getOperation()->getOperandTypes()";
   if (isa<ResultsDirective>(arg))
     return body << "getOperation()->getResultTypes()";
   auto *operand = dyn_cast<OperandVariable>(arg);
   auto *var = operand ? operand->getVar() : cast<ResultVariable>(arg)->getVar();
   if (var->isVariadicOfVariadic())
-    return body << llvm::formatv("{0}().join().getTypes()", var->name);
+    return body << llvm::formatv("{0}().join().getTypes()",
+                                 op.getGetterName(var->name));
   if (var->isVariadic())
-    return body << var->name << "().getTypes()";
+    return body << op.getGetterName(var->name) << "().getTypes()";
   if (var->isOptional())
     return body << llvm::formatv(
                "({0}() ? ::llvm::ArrayRef<::mlir::Type>({0}().getType()) : "
                "::llvm::ArrayRef<::mlir::Type>())",
-               var->name);
-  return body << "::llvm::ArrayRef<::mlir::Type>(" << var->name
-              << "().getType())";
+               op.getGetterName(var->name));
+  return body << "::llvm::ArrayRef<::mlir::Type>("
+              << op.getGetterName(var->name) << "().getType())";
 }
 
 /// Generate the printer for an enum attribute.
-static void genEnumAttrPrinter(const NamedAttribute *var, OpMethodBody &body) {
+static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
+                               OpMethodBody &body) {
   Attribute baseAttr = var->attr.getBaseAttr();
   const EnumAttr &enumAttr = cast<EnumAttr>(baseAttr);
   std::vector<EnumAttrCase> cases = enumAttr.getAllCases();
 
   body << llvm::formatv(enumAttrBeginPrinterCode,
-                        (var->attr.isOptional() ? "*" : "") + var->name,
+                        (var->attr.isOptional() ? "*" : "") +
+                            op.getGetterName(var->name),
                         enumAttr.getSymbolToStringFnName());
 
   // Get a string containing all of the cases that can't be represented with a
   // keyword.
   llvm::BitVector nonKeywordCases(cases.size());
   bool hasStrCase = false;
   for (auto it : llvm::enumerate(cases)) {
     hasStrCase = it.value().isStrCase();
if (nonKeywordCases.any()) {
     return;
   }
 
   body << "    p << caseValueStr;\n"
           "  }\n";
 }
 
 /// Generate the check for the anchor of an optional group.
-static void genOptionalGroupPrinterAnchor(Element *anchor, OpMethodBody &body) {
+static void genOptionalGroupPrinterAnchor(Element *anchor, const Operator &op,
+                                          OpMethodBody &body) {
   TypeSwitch<Element *>(anchor)
       .Case<OperandVariable, ResultVariable>([&](auto *element) {
         const NamedTypeConstraint *var = element->getVar();
+        std::string name = op.getGetterName(var->name);
         if (var->isOptional())
-          body << "  if (" << var->name << "()) {\n";
+          body << "  if (" << name << "()) {\n";
         else if (var->isVariadic())
-          body << "  if (!" << var->name << "().empty()) {\n";
+          body << "  if (!" << name << "().empty()) {\n";
       })
       .Case<RegionVariable>([&](RegionVariable *element) {
         const NamedRegion *var = element->getVar();
+        std::string name = op.getGetterName(var->name);
         // TODO: Add a check for optional regions here when ODS supports it.
-        body << "  if (!" << var->name << "().empty()) {\n";
+        body << "  if (!" << name << "().empty()) {\n";
       })
       .Case<TypeDirective>([&](TypeDirective *element) {
-        genOptionalGroupPrinterAnchor(element->getOperand(), body);
+        genOptionalGroupPrinterAnchor(element->getOperand(), op, body);
       })
       .Case<FunctionalTypeDirective>([&](FunctionalTypeDirective *element) {
-        genOptionalGroupPrinterAnchor(element->getInputs(), body);
+        genOptionalGroupPrinterAnchor(element->getInputs(), op, body);
       })
       .Case<AttributeVariable>([&](AttributeVariable *attr) {
         body << "  if ((*this)->getAttr(\"" << attr->getVar()->name
              << "\")) {\n";
       });
 }
 
 void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
   if (SpaceElement *space = dyn_cast<SpaceElement>(element))
     return genSpacePrinter(space->getValue(), body, shouldEmitSpace,
                            lastWasPunctuation);
 
   // Emit an optional group.
   if (OptionalElement *optional = dyn_cast<OptionalElement>(element)) {
     // Emit the check for the presence of the anchor element.
     Element *anchor = optional->getAnchor();
-    genOptionalGroupPrinterAnchor(anchor, body);
+    genOptionalGroupPrinterAnchor(anchor, op, body);
 
     // If the anchor is a unit attribute, we don't need to print it. When
     // parsing, we will add this attribute if this group is present.
     auto elements = optional->getThenElements();
     Element *elidedAnchorElement = nullptr;
     auto *anchorAttr = dyn_cast<AttributeVariable>(anchor);
     if (anchorAttr && anchorAttr != &*elements.begin() &&
         anchorAttr->isUnitAttr()) {
void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
   lastWasPunctuation = false;
   shouldEmitSpace = true;
 
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     const NamedAttribute *var = attr->getVar();
 
     // If we are formatting as an enum, symbolize the attribute as a string.
     if (canFormatEnumAttr(var))
-      return genEnumAttrPrinter(var, body);
+      return genEnumAttrPrinter(var, op, body);
 
     // If we are formatting as a symbol name, handle it as a symbol name.
     if (shouldFormatSymbolNameAttr(var)) {
-      body << "  p.printSymbolName(" << var->name << "Attr().getValue());\n";
+      body << "  p.printSymbolName(" << op.getGetterName(var->name)
+           << "Attr().getValue());\n";
       return;
     }
 
     // Elide the attribute type if it is buildable.
     if (attr->getTypeBuilder())
-      body << "  p.printAttributeWithoutType(" << var->name << "Attr());\n";
+      body << "  p.printAttributeWithoutType(" << op.getGetterName(var->name)
+           << "Attr());\n";
     else
-      body << "  p.printAttribute(" << var->name << "Attr());\n";
+      body << "  p.printAttribute(" << op.getGetterName(var->name)
+           << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     if (operand->getVar()->isVariadicOfVariadic()) {
-      body << "  ::llvm::interleaveComma(" << operand->getVar()->name
+      body << "  ::llvm::interleaveComma("
+           << op.getGetterName(operand->getVar()->name)
            << "(), p, [&](const auto &operands) { p << \"(\" << operands << "
               "\")\"; });\n";
 
     } else if (operand->getVar()->isOptional()) {
-      body << "  if (::mlir::Value value = " << operand->getVar()->name
-           << "())\n"
+      body << "  if (::mlir::Value value = "
+           << op.getGetterName(operand->getVar()->name) << "())\n"
            << "    p << value;\n";
     } else {
-      body << "  p << " << operand->getVar()->name << "();\n";
+      body << "  p << " << op.getGetterName(operand->getVar()->name) << "();\n";
     }
   } else if (auto *region = dyn_cast<RegionVariable>(element)) {
     const NamedRegion *var = region->getVar();
+    std::string name = op.getGetterName(var->name);
     if (var->isVariadic()) {
-      genVariadicRegionPrinter(var->name + "()", body, hasImplicitTermTrait);
+      genVariadicRegionPrinter(name + "()", body, hasImplicitTermTrait);
     } else {
-      genRegionPrinter(var->name + "()", body, hasImplicitTermTrait);
+      genRegionPrinter(name + "()", body, hasImplicitTermTrait);
     }
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
+    std::string name = op.getGetterName(var->name);
     if (var->isVariadic())
-      body << "  ::llvm::interleaveComma(" << var->name << "(), p);\n";
+      body << "  ::llvm::interleaveComma(" << name << "(), p);\n";
     else
-      body << "  p << " << var->name << "();\n";
+      body << "  p << " << name << "();\n";
   } else if (auto *dir = dyn_cast<CustomDirective>(element)) {
-    genCustomDirectivePrinter(dir, body);
+    genCustomDirectivePrinter(dir, op, body);
   } else if (isa<OperandsDirective>(element)) {
     body << "  p << getOperation()->getOperands();\n";
   } else if (isa<RegionsDirective>(element)) {
     genVariadicRegionPrinter("getOperation()->getRegions()", body,
                              hasImplicitTermTrait);
   } else if (isa<SuccessorsDirective>(element)) {
     body << "  ::llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     if (auto *operand = dyn_cast<OperandVariable>(dir->getOperand())) {
       if (operand->getVar()->isVariadicOfVariadic()) {
         body << llvm::formatv("  ::llvm::interleaveComma({0}().getTypes(), p, "
                               "[&](::mlir::TypeRange types) {{ p << \"(\" << "
                               "types << \")\"; });\n",
-                              operand->getVar()->name);
+                              op.getGetterName(operand->getVar()->name));
         return;
       }
     }
     body << "  p << ";
-    genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
+    genTypeOperandPrinter(dir->getOperand(), op, body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     body << "  p.printFunctionalType(";
-    genTypeOperandPrinter(dir->getInputs(), body) << ", ";
-    genTypeOperandPrinter(dir->getResults(), body) << ");\n";
+    genTypeOperandPrinter(dir->getInputs(), op, body) << ", ";
+    genTypeOperandPrinter(dir->getResults(), op, body) << ");\n";
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
 void OperationFormat::genPrinter(Operator &op, OpClass &opClass) {
   auto *method =
       opClass.addMethodAndPrune("void", "print", "::mlir::OpAsmPrinter &p");