[mlir] Remove support for non-prefixed accessors

[rriddle]

Summary

This finishes off a year long pursuit to LLVMify the generated
operation accessors, prefixing them with get/set. Support for
any other accessor naming is fully removed after this commit.

https://discourse.llvm.org/t/psa-raw-accessors-are-being-removed/65629

[tpopp]

Are you still going to wait until early November, or are you going to commit it this week?

[rriddle]

In D136727#3884816, @tpopp wrote:

Are you still going to wait until early November, or are you going to commit it this week?

I'll wait until early November (like in the post), just sent this out to prepare for that.

[Mogball]

The End of an Era

[tpopp]

In D136727#3886133, @rriddle wrote:

In D136727#3884816, @tpopp wrote:

Are you still going to wait until early November, or are you going to commit it this week?

I'll wait until early November (like in the post), just sent this out to prepare for that.

Thank you, and I hope my question wasn't too abrupt, as I just wanted to check while preparing for handling this in my org.

[rriddle]

In D136727#3897964, @tpopp wrote:

In D136727#3886133, @rriddle wrote:

In D136727#3884816, @tpopp wrote:

Are you still going to wait until early November, or are you going to commit it this week?

I'll wait until early November (like in the post), just sent this out to prepare for that.

Thank you, and I hope my question wasn't too abrupt, as I just wanted to check while preparing for handling this in my org.

No worries at all!

[mehdi_amini]

Do you think we could wait until after the LLVM Dev meeting MLIR Summit to land this? We're kind of scrambling around these days and still working on preparing for this to land.

[rriddle]

In D136727#3898123, @mehdi_amini wrote:

Do you think we could wait until after the LLVM Dev meeting MLIR Summit to land this? We're kind of scrambling around these days and still working on preparing for this to land.

Yeah, that's fine.

[tpopp]

In D136727#3898124, @rriddle wrote:

In D136727#3898123, @mehdi_amini wrote:

Do you think we could wait until after the LLVM Dev meeting MLIR Summit to land this? We're kind of scrambling around these days and still working on preparing for this to land.

Yeah, that's fine.

Thank you very much for waiting a while more on this.

[jpienaar]

Nice amount of red :-)

mlir/docs/DefiningDialects.md

305

Is this recorded somewhere still post? This is default now.

We may also want to warn when attributes overlap with more helpful message in the case where it is due to this transform, e.g., t and T now map to same accessor where it didn't before and some renaming would be needed (a bit unfortunate that I didn't add that check earlier). [Not blocker, could just be GitHub issue too]

[rriddle]

mlir/docs/DefiningDialects.md

305

I think we do emit an error if we generate an overlap, but not sure it's the nicest error.

Added back a blurb on accessor generation.

flang/lib/Optimizer/Transforms/AbstractResult.cpp

if (hasAbstractResult(funcTy)) {
         mlir::Value newArg = func.getArgument(0u);
         if (mustEmboxResult(resultType, shouldBoxResult)) {
           auto bufferType = fir::ReferenceType::get(resultType);
           rewriter.setInsertionPointToStart(&func.front());
           newArg = rewriter.create<fir::BoxAddrOp>(loc, bufferType, newArg);
         }
         patterns.insert<ReturnOpConversion>(context, newArg);
         target.addDynamicallyLegalOp<mlir::func::ReturnOp>(
-            [](mlir::func::ReturnOp ret) { return ret.operands().empty(); });
+            [](mlir::func::ReturnOp ret) { return ret.getOperands().empty(); });
         assert(func.getFunctionType() ==
                getNewFunctionType(funcTy, shouldBoxResult));
       } else {
         llvm::SmallVector<mlir::DictionaryAttr> allArgs;
         func.getAllArgAttrs(allArgs);
         allArgs.insert(allArgs.begin(),
                        mlir::DictionaryAttr::get(func->getContext()));
         func.setType(getNewFunctionType(funcTy, shouldBoxResult));

mlir/docs/DefiningDialects.md

 use `"::"` as the delimiter between namespace, e.g., given `"A::B"`, C++ classes will be placed
 within: `namespace A { namespace B { <classes> } }`.
 
 Note that this works in conjunction with the dialect's C++ code. Depending on how the generated files
 are included, you may want to specify a full namespace path or a partial one. In general, it's best
 to use full namespaces whenever you can. This makes it easier for dialects within different namespaces,
 and projects, to interact with each other.
 
+### C++ Accessor Generation
+
+When generating accessors for dialects and their components (attributes, operations, types, etc.),
+we prefix the name with `get` and `set` respectively, and transform `snake_style` names to camel
+case (`UpperCamel` when prefixed, and `lowerCamel` for individual variable names). For example, if an
+operation were defined as:
+
+```tablegen
+def MyOp : MyDialect<"op"> {
+  let arguments = (ins StrAttr:$value, StrAttr:$other_value);
+}
+```
+
+It would have accessors generated for the `value` and `other_value` attributes as follows:
+
+```c++
+StringAttr MyOp::getValue();
+void MyOp::setValue(StringAttr newValue);
+
+StringAttr MyOp::getOtherValue();
+void MyOp::setOtherValue(StringAttr newValue);
+```
+
 ### Dependent Dialects
 
 MLIR has a very large ecosystem, and contains dialects that server many different purposes. It
 is quite common, given the above, that dialects may want to reuse certain components from other
 dialects. This may mean generating operations from those dialects during canonicalization, reusing
 attributes or types, etc. When a dialect has a dependency on another, i.e. when it constructs and/or
 generally relies on the components of another dialect, a dialect dependency should be explicitly
 recorded. An explicitly dependency ensures that dependent dialects are loaded alongside the

 ```c++
 /// Return the canonicalization patterns for this dialect:
 void MyDialect::getCanonicalizationPatterns(RewritePatternSet &results) const;
 ```
 
 See the documentation for [Canonicalization in MLIR](Canonicalization.md) for a much more 
 detailed description about canonicalization patterns.
 
-### C++ Accessor Prefix
-
-Historically, MLIR has generated accessors for operation components (such as attribute, operands, 
-results) using the tablegen definition name verbatim. This means that if an operation was defined
-as:
-
-```tablegen
-def MyOp : MyDialect<"op"> {
-  let arguments = (ins StrAttr:$value, StrAttr:$other_value);
-}
-```
-
-It would have accessors generated for the `value` and `other_value` attributes as follows:
-
-```c++
-StringAttr MyOp::value();
-void MyOp::value(StringAttr newValue);
-
-StringAttr MyOp::other_value();
-void MyOp::other_value(StringAttr newValue);
-```
-
-Since then, we have decided to move accessors over to a style that matches the rest of the
-code base. More specifically, this means that we prefix accessors with `get` and `set`
-respectively, and transform `snake_style` names to camel case (`UpperCamel` when prefixed,
-and `lowerCamel` for individual variable names). If we look at the same example as above, this
-would produce:
-
-```c++
-StringAttr MyOp::getValue();
-void MyOp::setValue(StringAttr newValue);
-
-StringAttr MyOp::getOtherValue();
-void MyOp::setOtherValue(StringAttr newValue);
-```
-
-The form in which accessors are generated is controlled by the `emitAccessorPrefix` field.
-This field may any of the following values:
-
-* `kEmitAccessorPrefix_Raw`
-  - Don't emit any `get`/`set` prefix.
-
-* `kEmitAccessorPrefix_Prefixed`
-  - Only emit with `get`/`set` prefix.
-
-* `kEmitAccessorPrefix_Both`
-  - Emit with **and** without prefix.
-
-All new dialects are strongly encouraged to use the default `kEmitAccessorPrefix_Prefixed`
-value, as the `Raw` form is deprecated and in the process of being removed.
-
-Note: Remove this section when all dialects have been switched to the new accessor form.
-
 ## Defining an Extensible dialect
 
 This section documents the design and API of the extensible dialects. Extensible
 dialects are dialects that can be extended with new operations and types defined
 at runtime. This allows for users to define dialects via with meta-programming,
 or from another language, without having to recompile C++ code.
 
 ### Defining an extensible dialect

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

let builders = [
     [{
       build($_builder, $_state, $_builder.getIndexType(), affineMap, mapOperands);
     }]>
   ];
 
   let extraClassDeclaration = [{
     static StringRef getMapAttrStrName() { return "map"; }
     AffineMap getAffineMap() { return getMap(); }
-    ValueRange getMapOperands() { return operands(); }
+    ValueRange getMapOperands() { return getOperands(); }
     ValueRange getDimOperands() {
-      return OperandRange{operands().begin(),
-                        operands().begin() + getMap().getNumDims()};
+      return OperandRange{getOperands().begin(),
+                          getOperands().begin() + getMap().getNumDims()};
     }
     ValueRange getSymbolOperands() {
-      return OperandRange{operands().begin() + getMap().getNumDims(),
-                        operands().end()};
+      return OperandRange{getOperands().begin() + getMap().getNumDims(),
+                          getOperands().end()};
     }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 

mlir/include/mlir/IR/DialectBase.td

 
 #ifndef DIALECTBASE_TD
 #define DIALECTBASE_TD
 
 //===----------------------------------------------------------------------===//
 // Dialect definitions
 //===----------------------------------------------------------------------===//
 
-// "Enum" values for emitAccessorPrefix of Dialect.
-defvar kEmitAccessorPrefix_Raw = 0;      // Don't emit any getter/setter prefix.
-defvar kEmitAccessorPrefix_Prefixed = 1; // Only emit with getter/setter prefix.
-defvar kEmitAccessorPrefix_Both = 2;     // Emit without and with prefix.
-
 class Dialect {
   // The name of the dialect.
   string name = ?;
 
   // Short summary of the dialect.
   string summary = ?;
 
   // The description of the dialect.
class Dialect {
   // When set, ODS will generate declarations for the type parsing and printing
   // hooks in the dialect and default implementations that dispatch to each
   // individual type directly.
   bit useDefaultTypePrinterParser = 0;
 
   // If this dialect overrides the hook for canonicalization patterns.
   bit hasCanonicalizer = 0;
 
-  // Whether to emit raw/with no prefix or format changes, or emit with
-  // accessor with prefix only and UpperCamel suffix or to emit accessors with
-  // both.
-  //
-  // If emitting with prefix is specified then the attribute/operand's
-  // name is converted to UpperCamel from snake_case (which would result in
-  // leaving UpperCamel unchanged while also converting lowerCamel to
-  // UpperCamel) and prefixed with `get` or `set` depending on if it is a getter
-  // or setter.
-  int emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
-
   // If this dialect can be extended at runtime with new operations or types.
   bit isExtensible = 0;
 }
 
 #endif // DIALECTBASE_TD

mlir/include/mlir/TableGen/Dialect.h

public:
   bool operator!=(const Dialect &other) const { return !(*this == other); }
 
   // Compares two dialects by comparing the names of the dialects.
   bool operator<(const Dialect &other) const;
 
   // Returns whether the dialect is defined.
   explicit operator bool() const { return def != nullptr; }
 
-  // Returns how the accessors should be prefixed in dialect.
-  enum class EmitPrefix { Raw = 0, Prefixed = 1, Both = 2 };
-  EmitPrefix getEmitAccessorPrefix() const;
-
 private:
   const llvm::Record *def;
   std::vector<StringRef> dependentDialects;
 };
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_DIALECT_H_

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 getter name for the accessor of `name`.
+  std::string getGetterName(StringRef name) const;
 
-  // Returns the setter names for the accessor.
-  SmallVector<std::string, 2> getSetterNames(StringRef name) const;
+  // Returns the setter name for the accessor of `name`.
+  std::string getSetterName(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(

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 namespace {
 class AffineMinLowering : public OpRewritePattern<AffineMinOp> {
 public:
   using OpRewritePattern<AffineMinOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AffineMinOp op,
                                 PatternRewriter &rewriter) const override {
     Value reduced =
-        lowerAffineMapMin(rewriter, op.getLoc(), op.getMap(), op.operands());
+        lowerAffineMapMin(rewriter, op.getLoc(), op.getMap(), op.getOperands());
     if (!reduced)
       return failure();
 
     rewriter.replaceOp(op, reduced);
     return success();
   }
 };
 
 class AffineMaxLowering : public OpRewritePattern<AffineMaxOp> {
 public:
   using OpRewritePattern<AffineMaxOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AffineMaxOp op,
                                 PatternRewriter &rewriter) const override {
     Value reduced =
-        lowerAffineMapMax(rewriter, op.getLoc(), op.getMap(), op.operands());
+        lowerAffineMapMax(rewriter, op.getLoc(), op.getMap(), op.getOperands());
     if (!reduced)
       return failure();
 
     rewriter.replaceOp(op, reduced);
     return success();
   }
 };
 
 /// Affine yields ops are removed.
 class AffineYieldOpLowering : public OpRewritePattern<AffineYieldOp> {
 public:
   using OpRewritePattern<AffineYieldOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AffineYieldOp op,
                                 PatternRewriter &rewriter) const override {
     if (isa<scf::ParallelOp>(op->getParentOp())) {
       // scf.parallel does not yield any values via its terminator scf.yield but
       // models reductions differently using additional ops in its region.
       rewriter.replaceOpWithNewOp<scf::YieldOp>(op);
       return success();
     }
-    rewriter.replaceOpWithNewOp<scf::YieldOp>(op, op.operands());
+    rewriter.replaceOpWithNewOp<scf::YieldOp>(op, op.getOperands());
     return success();
   }
 };
 
 class AffineForLowering : public OpRewritePattern<AffineForOp> {
 public:
   using OpRewritePattern<AffineForOp>::OpRewritePattern;
 

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

 
 // Converts !gpu.async.token operands of `async.yield` to runtime calls. The
 // !gpu.async.token are lowered to stream within the async.execute region, but
 // are passed as events between them. For each !gpu.async.token operand, we
 // create an event and record it on the stream.
 LogicalResult ConvertAsyncYieldToGpuRuntimeCallPattern::matchAndRewrite(
     async::YieldOp yieldOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  if (llvm::none_of(yieldOp.operands(), isGpuAsyncTokenType))
+  if (llvm::none_of(yieldOp.getOperands(), isGpuAsyncTokenType))
     return rewriter.notifyMatchFailure(yieldOp, "no gpu async token operand");
 
   Location loc = yieldOp.getLoc();
   SmallVector<Value, 4> newOperands(adaptor.getOperands());
   llvm::SmallDenseSet<Value> streams;
   for (auto &operand : yieldOp->getOpOperands()) {
     if (!isGpuAsyncTokenType(operand.get()))
       continue;

mlir/lib/Dialect/Async/IR/Async.cpp

if (getOperandTypes() != types)
     return emitOpError("operand types do not match the types returned from "
                        "the parent ExecuteOp");
 
   return success();
 }
 
 MutableOperandRange
 YieldOp::getMutableSuccessorOperands(Optional<unsigned> index) {
-  return operandsMutable();
+  return getOperandsMutable();
 }
 
 //===----------------------------------------------------------------------===//
 /// ExecuteOp
 //===----------------------------------------------------------------------===//
 
 constexpr char kOperandSegmentSizesAttr[] = "operand_segment_sizes";
 

mlir/lib/Dialect/Bufferization/Transforms/DropEquivalentBufferResults.cpp

for (auto funcOp : module.getOps<func::FuncOp>()) {
     // TODO: Support functions with multiple blocks.
     if (!returnOp)
       continue;
 
     // Compute erased results.
     SmallVector<Value> newReturnValues;
     BitVector erasedResultIndices(funcOp.getFunctionType().getNumResults());
     DenseMap<int64_t, int64_t> resultToArgs;
-    for (const auto &it : llvm::enumerate(returnOp.operands())) {
+    for (const auto &it : llvm::enumerate(returnOp.getOperands())) {
       bool erased = false;
       for (BlockArgument bbArg : funcOp.getArguments()) {
         Value val = it.value();
         while (auto castOp = val.getDefiningOp<memref::CastOp>())
           val = castOp.getSource();
 
         if (val == bbArg) {
           resultToArgs[it.index()] = bbArg.getArgNumber();
           erased = true;
           break;
         }
       }
 
       if (erased) {
         erasedResultIndices.set(it.index());
       } else {
         newReturnValues.push_back(it.value());
       }
     }
 
     // Update function.
     funcOp.eraseResults(erasedResultIndices);
-    returnOp.operandsMutable().assign(newReturnValues);
+    returnOp.getOperandsMutable().assign(newReturnValues);
 
     // Update function calls.
     module.walk([&](func::CallOp callOp) {
       if (getCalledFunction(callOp) != funcOp)
         return WalkResult::skip();
 
       rewriter.setInsertionPoint(callOp);
       auto newCallOp = rewriter.create<func::CallOp>(callOp.getLoc(), funcOp,
-                                                     callOp.operands());
+                                                     callOp.getOperands());
       SmallVector<Value> newResults;
       int64_t nextResult = 0;
       for (int64_t i = 0; i < callOp.getNumResults(); ++i) {
         if (!resultToArgs.count(i)) {
           // This result was not erased.
           newResults.push_back(newCallOp.getResult(nextResult++));
           continue;
         }

mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp

for (OpOperand &returnOperand : returnOp->getOpOperands()) {
         resultType = getMemRefTypeWithFullyDynamicLayout(tensorType);
       }
       Value toMemrefOp = rewriter.create<bufferization::ToMemrefOp>(
           loc, resultType, returnVal);
       returnValues.push_back(toMemrefOp);
     }
 
     // 3. Rewrite the terminator without the in-place bufferizable values.
-    returnOp.operandsMutable().assign(returnValues);
+    returnOp.getOperandsMutable().assign(returnValues);
 
     // 4. Rewrite the FuncOp type to buffer form.
     funcOp.setType(FunctionType::get(op->getContext(), argTypes,
                                      ValueRange(returnValues).getTypes()));
 
     return success();
   }
 

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult gpu::ReturnOp::verify() {
   GPUFuncOp function = (*this)->getParentOfType<GPUFuncOp>();
 
   FunctionType funType = function.getFunctionType();
 
-  if (funType.getNumResults() != operands().size())
+  if (funType.getNumResults() != getOperands().size())
     return emitOpError()
         .append("expected ", funType.getNumResults(), " result operands")
         .attachNote(function.getLoc())
         .append("return type declared here");
 
   for (const auto &pair : llvm::enumerate(
-           llvm::zip(function.getFunctionType().getResults(), operands()))) {
+           llvm::zip(function.getFunctionType().getResults(), getOperands()))) {
     auto [type, operand] = pair.value();
     if (type != operand.getType())
       return emitOpError() << "unexpected type `" << operand.getType()
                            << "' for operand #" << pair.index();
   }
   return success();
 }
 

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

for (unsigned i = 0; i < t1.getRank(); ++i) {
       if (!v1 || !v2)
         return false;
 
       // Case 2: Both values are identical AffineMinOps. (Should not happen if
       // CSE is run.)
       auto minOp1 = v1.getDefiningOp<AffineMinOp>();
       auto minOp2 = v2.getDefiningOp<AffineMinOp>();
       if (minOp1 && minOp2 && minOp1.getAffineMap() == minOp2.getAffineMap() &&
-          minOp1.operands() == minOp2.operands())
+          minOp1.getOperands() == minOp2.getOperands())
         continue;
 
       // Add additional cases as needed.
     }
 
     // All tests passed.
     return true;
   }

mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp

auto loopMatcher = [](Value iv, OpFoldResult &lb, OpFoldResult &ub,
             return success();
           }
         }
         return failure();
       }
       return failure();
     };
 
-    return scf::canonicalizeMinMaxOpInLoop(rewriter, op, op.getAffineMap(),
-                                           op.operands(), IsMin, loopMatcher);
+    return scf::canonicalizeMinMaxOpInLoop(
+        rewriter, op, op.getAffineMap(), op.getOperands(), IsMin, loopMatcher);
   }
 };
 
 struct SCFForLoopCanonicalization
     : public impl::SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
   void runOnOperation() override {
     auto *parentOp = getOperation();
     MLIRContext *ctx = parentOp->getContext();

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

static void rewriteAffineOpAfterPeeling(RewriterBase &rewriter, ForOp forOp,
   Value partialIv = partialIteration.getInductionVar();
   assert(forOp.getStep() == partialIteration.getStep() &&
          "expected same step in main and partial loop");
   Value step = forOp.getStep();
 
   forOp.walk([&](OpTy affineOp) {
     AffineMap map = affineOp.getAffineMap();
     (void)scf::rewritePeeledMinMaxOp(rewriter, affineOp, map,
-                                     affineOp.operands(), IsMin, mainIv,
+                                     affineOp.getOperands(), IsMin, mainIv,
                                      previousUb, step,
                                      /*insideLoop=*/true);
   });
   partialIteration.walk([&](OpTy affineOp) {
     AffineMap map = affineOp.getAffineMap();
     (void)scf::rewritePeeledMinMaxOp(rewriter, affineOp, map,
-                                     affineOp.operands(), IsMin, partialIv,
+                                     affineOp.getOperands(), IsMin, partialIv,
                                      previousUb, step, /*insideLoop=*/false);
   });
 }
 
 LogicalResult mlir::scf::peelAndCanonicalizeForLoop(RewriterBase &rewriter,
                                                     ForOp forOp,
                                                     ForOp &partialIteration) {
   Value previousUb = forOp.getUpperBound();

mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp

LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto assumingOp = cast<shape::AssumingOp>(op);
     assert(assumingOp.getDoRegion().getBlocks().size() == 1 &&
            "only 1 block supported");
     auto yieldOp = cast<shape::AssumingYieldOp>(
         assumingOp.getDoRegion().front().getTerminator());
 
     // Create new op and move over region.
-    TypeRange newResultTypes(yieldOp.operands());
+    TypeRange newResultTypes(yieldOp.getOperands());
     auto newOp = rewriter.create<shape::AssumingOp>(
         op->getLoc(), newResultTypes, assumingOp.getWitness());
     newOp.getDoRegion().takeBody(assumingOp.getRegion());
 
     // Update all uses of the old op.
     rewriter.setInsertionPointAfter(newOp);
     SmallVector<Value> newResults;
     for (const auto &it : llvm::enumerate(assumingOp->getResultTypes())) {
bool mustBufferizeInPlace(Operation *op, OpOperand &opOperand,
     // when possible.
     return true;
   }
 
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
     auto yieldOp = cast<shape::AssumingYieldOp>(op);
     SmallVector<Value> newResults;
-    for (Value value : yieldOp.operands()) {
+    for (Value value : yieldOp.getOperands()) {
       if (value.getType().isa<TensorType>()) {
         FailureOr<Value> buffer = getBuffer(rewriter, value, options);
         if (failed(buffer))
           return failure();
         newResults.push_back(*buffer);
       } else {
         newResults.push_back(value);
       }

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CreateMaskOp createMaskOp,
                                 PatternRewriter &rewriter) const override {
     // Return if any of 'createMaskOp' operands are not defined by a constant.
     auto isNotDefByConstant = [](Value operand) {
       return !isa_and_nonnull<arith::ConstantIndexOp>(operand.getDefiningOp());
     };
-    if (llvm::any_of(createMaskOp.operands(), isNotDefByConstant))
+    if (llvm::any_of(createMaskOp.getOperands(), isNotDefByConstant))
       return failure();
 
     // CreateMaskOp for scalable vectors can be folded only if all dimensions
     // are negative or zero.
     if (auto vType = createMaskOp.getType().dyn_cast<VectorType>()) {
       if (vType.isScalable())
         for (auto opDim : createMaskOp.getOperands()) {
           APInt intVal;
           if (matchPattern(opDim, m_ConstantInt(&intVal)) &&
               intVal.isStrictlyPositive())
             return failure();
         }
     }
 
     // Gather constant mask dimension sizes.
     SmallVector<int64_t, 4> maskDimSizes;
     maskDimSizes.reserve(createMaskOp->getNumOperands());
     for (auto [operand, maxDimSize] : llvm::zip_equal(
-             createMaskOp.operands(), createMaskOp.getType().getShape())) {
+             createMaskOp.getOperands(), createMaskOp.getType().getShape())) {
       Operation *defOp = operand.getDefiningOp();
       int64_t dimSize = cast<arith::ConstantIndexOp>(defOp).value();
       dimSize = std::min(dimSize, maxDimSize);
       // If one of dim sizes is zero, set all dims to zero.
       if (dimSize <= 0) {
         maskDimSizes.assign(createMaskOp.getType().getRank(), 0);
         break;
       }

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

static WarpExecuteOnLane0Op moveRegionToNewWarpOpAndReplaceReturns(
   rewriter.eraseBlock(&newOpFirstBlock);
   assert(newWarpOp.getWarpRegion().hasOneBlock() &&
          "expected WarpOp with single block");
 
   auto yield =
       cast<vector::YieldOp>(newOpBody.getBlocks().begin()->getTerminator());
 
   rewriter.updateRootInPlace(
-      yield, [&]() { yield.operandsMutable().assign(newYieldedValues); });
+      yield, [&]() { yield.getOperandsMutable().assign(newYieldedValues); });
   return newWarpOp;
 }
 
 /// Helper to create a new WarpExecuteOnLane0Op region with extra outputs.
 /// `indices` return the index of each new output.
 static WarpExecuteOnLane0Op moveRegionToNewWarpOpAndAppendReturns(
     RewriterBase &rewriter, WarpExecuteOnLane0Op warpOp,
     ValueRange newYieldedValues, TypeRange newReturnTypes,
LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
 
     // Step 5. Insert appropriate writes within scf.if and reads after the
     // scf.if to transit the values returned by the op.
     // TODO: at this point, we can reuse the shared memory from previous
     // buffers.
     SmallVector<Value> replacements;
     auto yieldOp = cast<vector::YieldOp>(ifOp.thenBlock()->getTerminator());
     Location yieldLoc = yieldOp.getLoc();
-    for (const auto &it : llvm::enumerate(yieldOp.operands())) {
+    for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       Value sequentialVal = it.value();
       Value distributedVal = warpOp->getResult(it.index());
       DistributedLoadStoreHelper helper(sequentialVal, distributedVal,
                                         warpOp.getLaneid(), c0);
 
       // Create buffer before the ifOp.
       rewriter.setInsertionPoint(ifOp);
       Value buffer = options.warpAllocationFn(loc, rewriter, warpOp,
for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       // }
       // Both types are f32. The constant %cst is broadcasted to all lanes.
       // This is described in more detail in the documentation of the op.
       replacements.push_back(
           helper.buildLoad(rewriter, loc, distributedVal.getType(), buffer));
     }
 
     // Step 6. Insert sync after all the stores and before all the loads.
-    if (!yieldOp.operands().empty()) {
+    if (!yieldOp.getOperands().empty()) {
       rewriter.setInsertionPointAfter(ifOp);
       options.warpSyncronizationFn(loc, rewriter, warpOp);
     }
 
     // Step 7. Delete terminator and add empty scf.yield.
     rewriter.eraseOp(yieldOp);
     rewriter.setInsertionPointToEnd(ifOp.thenBlock());
     rewriter.create<scf::YieldOp>(yieldLoc);

mlir/lib/TableGen/Dialect.cpp

 bool Dialect::useDefaultAttributePrinterParser() const {
   return def->getValueAsBit("useDefaultAttributePrinterParser");
 }
 
 bool Dialect::useDefaultTypePrinterParser() const {
   return def->getValueAsBit("useDefaultTypePrinterParser");
 }
 
-Dialect::EmitPrefix Dialect::getEmitAccessorPrefix() const {
-  int prefix = def->getValueAsInt("emitAccessorPrefix");
-  if (prefix < 0 || prefix > static_cast<int>(EmitPrefix::Both))
-    PrintFatalError(def->getLoc(), "Invalid accessor prefix value");
-
-  return static_cast<EmitPrefix>(prefix);
-}
-
 bool Dialect::isExtensible() const {
   return def->getValueAsBit("isExtensible");
 }
 
 bool Dialect::operator==(const Dialect &other) const {
   return def == other.def;
 }
 
 bool Dialect::operator<(const Dialect &other) const {
   return getName() < other.getName();
 }

mlir/lib/TableGen/Operator.cpp

if (prefix.empty())
     return std::string(opName);
   return std::string(llvm::formatv("{0}.{1}", prefix, opName));
 }
 
 std::string Operator::getAdaptorName() const {
   return std::string(llvm::formatv("{0}Adaptor", getCppClassName()));
 }
 
+/// Assert the invariants of accessors generated for the given name.
+static void assertAccessorInvariants(const Operator &op, StringRef name) {
+  std::string accessorName =
+      convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
+
+  // Functor used to detect when an accessor will cause an overlap with an
+  // operation API.
+  //
+  // There are a little bit more invasive checks possible for cases where not
+  // all ops have the trait that would cause overlap. For many cases here,
+  // renaming would be better (e.g., we can only guard in limited manner
+  // against methods from traits and interfaces here, so avoiding these in op
+  // definition is safer).
+  auto nameOverlapsWithOpAPI = [&](StringRef newName) {
+    if (newName == "AttributeNames" || newName == "Attributes" ||
+        newName == "Operation")
+      return true;
+    if (newName == "Operands")
+      return op.getNumOperands() != 1 || op.getNumVariableLengthOperands() != 1;
+    if (newName == "Regions")
+      return op.getNumRegions() != 1 || op.getNumVariadicRegions() != 1;
+    if (newName == "Type")
+      return op.getNumResults() != 1;
+    return false;
+  };
+  if (nameOverlapsWithOpAPI(accessorName)) {
+    // This error could be avoided in situations where the final function is
+    // identical, but preferably the op definition should avoid using generic
+    // names.
+    PrintFatalError(op.getLoc(), "generated accessor for `" + name +
+                                     "` overlaps with a default one; please "
+                                     "rename to avoid overlap");
+  }
+}
+
 void Operator::assertInvariants() const {
   // Check that the name of arguments/results/regions/successors don't overlap.
   DenseMap<StringRef, StringRef> existingNames;
   auto checkName = [&](StringRef name, StringRef entity) {
     if (name.empty())
       return;
     auto insertion = existingNames.insert({name, entity});
-    if (insertion.second)
+    if (insertion.second) {
+      // Assert invariants for accessors generated for this name.
+      assertAccessorInvariants(*this, name);
       return;
+    }
     if (entity == insertion.first->second)
       PrintFatalError(getLoc(), "op has a conflict with two " + entity +
                                     " having the same name '" + name + "'");
     PrintFatalError(getLoc(), "op has a conflict with " +
                                   insertion.first->second + " and " + entity +
                                   " both having an entry with the name '" +
                                   name + "'");
   };
auto Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
   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;
-
-  // Whether to skip generating prefixed form for argument. This just does some
-  // basic checks.
-  //
-  // There are a little bit more invasive checks possible for cases where not
-  // all ops have the trait that would cause overlap. For many cases here,
-  // renaming would be better (e.g., we can only guard in limited manner against
-  // methods from traits and interfaces here, so avoiding these in op definition
-  // is safer).
-  auto skip = [&](StringRef newName) {
-    bool shouldSkip = newName == "getAttributeNames" ||
-                      newName == "getAttributes" || newName == "getOperation";
-    if (newName == "getOperands") {
-      // To reduce noise, skip generating the prefixed form and the warning if
-      // $operands correspond to single variadic argument.
-      if (op.getNumOperands() == 1 && op.getNumVariableLengthOperands() == 1)
-        return true;
-      shouldSkip = true;
-    }
-    if (newName == "getRegions") {
-      if (op.getNumRegions() == 1 && op.getNumVariadicRegions() == 1)
-        return true;
-      shouldSkip = true;
-    }
-    if (newName == "getType") {
-      if (op.getNumResults() != 1)
-        return false;
-      shouldSkip = true;
-    }
-    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, /*capitalizeFirst=*/true));
-    // Skip cases which would overlap with default ones for now.
-    if (skip(names.back())) {
-      rawToo = true;
-      names.clear();
-    } else if (rawToo) {
-      LLVM_DEBUG(llvm::errs() << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "::" << name << "\")\n"
-                              << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "Adaptor::" << name << "\")\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);
+std::string Operator::getGetterName(StringRef name) const {
+  return "get" + convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
 }
 
-SmallVector<std::string, 2> Operator::getSetterNames(StringRef name) const {
-  return getGetterOrSetterNames(/*isGetter=*/false, *this, name);
+std::string Operator::getSetterName(StringRef name) const {
+  return "set" + convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
 }

mlir/test/mlir-pdll/Parser/include/ops.td

def OpAllVariadic : Op<Test_Dialect, "all_variadic"> {
   let results = (outs Variadic<I64>:$results);
 }
 
 def OpMultipleSingleResult : Op<Test_Dialect, "multiple_single_result"> {
   let results = (outs I64:$result, I64:$result2);
 }
 
 def OpMultiVariadic : Op<Test_Dialect, "multi_variadic"> {
-  let arguments = (ins Variadic<I64>:$operands, Variadic<I64>:$operand2);
-  let results = (outs Variadic<I64>:$results, Variadic<I64>:$results2);
+  let arguments = (ins Variadic<I64>:$operands1, Variadic<I64>:$operand2);
+  let results = (outs Variadic<I64>:$results1, Variadic<I64>:$results2);
 }

mlir/test/mlir-tblgen/op-decl-and-defs.td

 // CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };
 
 // DEFS-LABEL: NS::AOp definitions
 
 // DEFS: AOpAdaptor::AOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions)
-// DEFS: ::mlir::RegionRange AOpAdaptor::getRegions()
 // DEFS: ::mlir::RegionRange AOpAdaptor::getSomeRegions()
 // DEFS-NEXT: return odsRegions.drop_front(1);
+// DEFS: ::mlir::RegionRange AOpAdaptor::getRegions()
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 )";
     method->body() << formatv(getAttrName, attributes.size());
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
   for (auto &attrIt : llvm::enumerate(llvm::make_first_range(attributes))) {
-    for (StringRef name : op.getGetterNames(attrIt.value())) {
-      std::string methodName = (name + "AttrName").str();
+    std::string name = op.getGetterName(attrIt.value());
+    std::string methodName = name + "AttrName";
 
-      // Generate the non-static variant.
-      {
-        auto *method =
-            opClass.addInlineMethod("::mlir::StringAttr", methodName);
-        ERROR_IF_PRUNED(method, methodName, op);
-        method->body() << llvm::formatv(attrNameMethodBody, attrIt.index());
-      }
+      auto *method = opClass.addInlineMethod("::mlir::StringAttr", methodName);
 
-      // Generate the static variant.
-      {
-        auto *method = opClass.addStaticInlineMethod(
-            "::mlir::StringAttr", methodName,
-            MethodParameter("::mlir::OperationName", "name"));
-        ERROR_IF_PRUNED(method, methodName, op);
-        method->body() << llvm::formatv(attrNameMethodBody,
-                                        "name, " + Twine(attrIt.index()));
-      }
-    }
-  }
-}
 
 // Emit the getter for an attribute with the return type specified.
 // It is templated to be shared between the Op and the adaptor class.
 template <typename OpClassOrAdaptor>
 static void emitAttrGetterWithReturnType(FmtContext &fctx,
                                          OpClassOrAdaptor &opClass,
                                          const Operator &op, StringRef name,
                                          Attribute attr) {
auto emitAttrWithStorageType = [&](StringRef name, StringRef attrName,
     method->body() << formatv(
         "  return {0}.{1}<{2}>();", emitHelper.getAttr(attrName),
         attr.isOptional() || attr.hasDefaultValue() ? "dyn_cast_or_null"
                                                     : "cast",
         attr.getStorageType());
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
-    for (StringRef name : op.getGetterNames(namedAttr.name)) {
-      if (namedAttr.attr.isDerivedAttr()) {
-        emitDerivedAttr(name, namedAttr.attr);
-      } else {
-        emitAttrWithStorageType(name, namedAttr.name, namedAttr.attr);
-        emitAttrGetterWithReturnType(fctx, opClass, op, name, namedAttr.attr);
-      }
-    }
-  }
+    std::string name = op.getGetterName(namedAttr.name);
 
   auto derivedAttrs = make_filter_range(op.getAttributes(),
                                         [](const NamedAttribute &namedAttr) {
                                           return namedAttr.attr.isDerivedAttr();
                                         });
   if (derivedAttrs.empty())
     return;
 
auto emitAttrWithReturnType = [&](StringRef setterName, StringRef getterName,
     method->body() << formatv(
         optionalCodeBody, getterName,
         constBuildAttrFromParam(baseAttr, fctx, paramStr));
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     if (namedAttr.attr.isDerivedAttr())
       continue;
-    for (auto [setterName, getterName] :
-         llvm::zip(op.getSetterNames(namedAttr.name),
-                   op.getGetterNames(namedAttr.name))) {
-      emitAttrWithStorageType(setterName, getterName, namedAttr.attr);
-      emitAttrWithReturnType(setterName, getterName, namedAttr.attr);
-    }
-  }
-}
+    std::string setterName = op.getSetterName(namedAttr.name);
+    std::string getterName = op.getGetterName(namedAttr.name);
 
 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.addMethod("::mlir::Attribute",
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 : op.getGetterNames(operand.name)) {
-      if (operand.isOptional()) {
-        m = opClass.addMethod(generateTypeForGetter(isAdaptor, operand), 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()) {
-        std::string segmentAttr = op.getGetterName(
-            operand.constraint.getVariadicOfVariadicSegmentSizeAttr());
-        if (isAdaptor) {
-          m = opClass.addMethod("::llvm::SmallVector<::mlir::ValueRange>",
-                                name);
-          ERROR_IF_PRUNED(m, name, op);
-          m->body() << llvm::formatv(variadicOfVariadicAdaptorCalcCode,
-                                     segmentAttr, i);
-          continue;
-        }
+    std::string name = op.getGetterName(operand.name);
+        m = opClass.addMethod("::llvm::SmallVector<::mlir::ValueRange>", name);
 
-        m = opClass.addMethod("::mlir::OperandRangeRange", name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << "  return getODSOperands(" << i << ").split("
-                  << segmentAttr << "Attr());";
-      } else if (operand.isVariadic()) {
-        m = opClass.addMethod(rangeType, name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << "  return getODSOperands(" << i << ");";
-      } else {
-        m = opClass.addMethod(generateTypeForGetter(isAdaptor, operand), name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << "  return *getODSOperands(" << i << ").begin();";
-      }
-    }
-  }
-}
+      m->body() << "  return getODSOperands(" << i << ").split(" << segmentAttr
+                << "Attr());";
 
 void OpEmitter::genNamedOperandGetters() {
   // 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,
                                emitHelper.getAttr(operandSegmentAttrName));

 
 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 : op.getGetterNames(operand.name)) {
-      auto *m = opClass.addMethod(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 << formatv(
-            ", ::mlir::MutableOperandRange::OperandSegment({0}u, *{1})", i,
-            emitHelper.getAttr(operandSegmentAttrName, /*isNamed=*/true));
-      }
-      body << ");\n";
+    std::string name = op.getGetterName(operand.name);
+
+                                name + "Mutable");
 
-      // 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("
-             << op.getGetterName(
-                    operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
-             << "AttrName()));\n";
-      } else {
-        // Otherwise, we use the full range directly.
-        body << "  return mutableRange;\n";
-      }
-    }
-  }
-}
 
 void OpEmitter::genNamedResultGetters() {
   const int numResults = op.getNumResults();
   const int numVariadicResults = op.getNumVariableLengthResults();
   const int numNormalResults = numResults - numVariadicResults;
 
   // If we have more than one variadic results, we need more complicated logic
   // to calculate the value range for each result.
void OpEmitter::genNamedResultGetters() {
   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 : op.getGetterNames(result.name)) {
-      if (result.isOptional()) {
-        m = opClass.addMethod(
-            generateTypeForGetter(/*isAdaptor=*/false, result), 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.addMethod("::mlir::Operation::result_range", name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << "  return getODSResults(" << i << ");";
-      } else {
-        m = opClass.addMethod(
-            generateTypeForGetter(/*isAdaptor=*/false, result), name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << "  return *getODSResults(" << i << ").begin();";
-      }
-    }
-  }
-}
+    std::string name = op.getGetterName(result.name);
+      m = opClass.addMethod(generateTypeForGetter(/*isAdaptor=*/false, result),
+                            name);
+      m = opClass.addMethod(generateTypeForGetter(/*isAdaptor=*/false, result),
+                            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;
+    std::string name = op.getGetterName(region.name);
 
-    for (StringRef name : op.getGetterNames(region.name)) {
-      // Generate the accessors for a variadic region.
-      if (region.isVariadic()) {
-        auto *m =
-            opClass.addMethod("::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.addMethod("::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 : op.getGetterNames(successor.name)) {
-      // Generate the accessors for a variadic successor list.
-      if (successor.isVariadic()) {
-        auto *m = opClass.addMethod("::mlir::SuccessorRange", name);
-        ERROR_IF_PRUNED(m, name, op);
-        m->body() << formatv(
-            "  return {std::next((*this)->successor_begin(), {0}), "
-            "(*this)->successor_end()};",
-            i);
-        continue;
-      }
+    std::string name = op.getGetterName(successor.name);
 
-      auto *m = opClass.addMethod("::mlir::Block *", name);
-      ERROR_IF_PRUNED(m, name, op);
-      m->body() << formatv("  return (*this)->getSuccessor({0});", i);
-    }
-  }
-}
 
 static bool canGenerateUnwrappedBuilder(const Operator &op) {
   // If this op does not have native attributes at all, return directly to avoid
   // redefining builders.
   if (op.getNumNativeAttributes() == 0)
     return false;
 
   bool canGenerate = false;
const auto *attrSizedOperands =
     auto *constructor =
         adaptor.addConstructor(MethodParameter(op.getCppClassName(), "op"));
     constructor->addMemberInitializer("odsOperands", "op->getOperands()");
     constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
     constructor->addMemberInitializer("odsOpName", "op->getName()");
   }
 
-  {
-    auto *m = adaptor.addMethod("::mlir::ValueRange", "getOperands");
-    ERROR_IF_PRUNED(m, "getOperands", op);
-    m->body() << "  return odsOperands;";
-  }
   std::string sizeAttrInit;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode,
                            emitHelper.getAttr(operandSegmentAttrName));
   }
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
+  // Any invalid overlap for `getOperands` will have been diagnosed before here
+  // already.
+  if (auto *m = adaptor.addMethod("::mlir::ValueRange", "getOperands"))
+    m->body() << "  return odsOperands;";
+
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
 
   // Generate named accessor with Attribute return type.
   auto emitAttrWithStorageType = [&](StringRef name, StringRef emitName,
                                      Attribute attr) {
     auto *method = adaptor.addMethod(attr.getStorageType(), emitName + "Attr");
     ERROR_IF_PRUNED(method, "Adaptor::" + emitName + "Attr", op);
auto emitAttrWithStorageType = [&](StringRef name, StringRef emitName,
     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())
       continue;
-    for (const auto &emitName : op.getGetterNames(name)) {
-      emitAttrWithStorageType(name, emitName, attr);
-      emitAttrGetterWithReturnType(fctx, adaptor, op, emitName, attr);
-    }
-  }
+    std::string emitName = op.getGetterName(name);
 
   unsigned numRegions = op.getNumRegions();
-  if (numRegions > 0) {
-    auto *m = adaptor.addMethod("::mlir::RegionRange", "getRegions");
-    ERROR_IF_PRUNED(m, "Adaptor::getRegions", op);
-    m->body() << "  return odsRegions;";
-  }
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
     // Generate the accessors for a variadic region.
-    for (StringRef name : op.getGetterNames(region.name)) {
-      if (region.isVariadic()) {
-        auto *m = adaptor.addMethod("::mlir::RegionRange", name);
-        ERROR_IF_PRUNED(m, "Adaptor::" + name, op);
-        m->body() << formatv("  return odsRegions.drop_front({0});", i);
-        continue;
-      }
+    std::string name = op.getGetterName(region.name);
 
-      auto *m = adaptor.addMethod("::mlir::Region &", name);
-      ERROR_IF_PRUNED(m, "Adaptor::" + name, op);
-      m->body() << formatv("  return *odsRegions[{0}];", i);
-    }
+  if (numRegions > 0) {
+    // Any invalid overlap for `getRegions` will have been diagnosed before here
+    // already.
+    if (auto *m = adaptor.addMethod("::mlir::RegionRange", "getRegions"))
+      m->body() << "  return odsRegions;";
   }
 
   // Add verification function.
   addVerification();
   adaptor.finalize();
 }
 
 void OpOperandAdaptorEmitter::addVerification() {