[mlir][tblgen] Generate generic adaptors for Ops

[zero9178]

Summary

This is part of the RFC for a better fold API: https://discourse.llvm.org/t/rfc-a-better-fold-api-using-more-generic-adaptors/67374

This patch implements the generation of generic adaptors through TableGen. These are essentially a generalization of Adaptors, as implemented previously, but instead of indexing into a mlir::ValueRange, they may index into any container, regardless of the element type. This allows the use of the convenient getter methods of Adaptors to be reused on ranges that are the result of some kind of mapping functions of an ops operands.
In the case of the fold API in the RFC, this would be ArrayRef<Attribute>, which is a mapping of the operands to their possibly-constant values.

Implementation wise, some special care was taken to not cause a compile time regression, nor to break any kind of source compatibility.
For that purpose, the current adaptor class was split into three:

• A generic adaptor base class, within the detail namespace as it is an implementation detail, which implements all APIs independent of the range type used for the operands. This is all the attribute and region related code. Since it is not templated, its implementation does not have to be inline and can be put into the cpp source file
• The actual generic adaptor, which has a template parameter for the range that should be indexed into for retrieving operands. It implements all the getters for operands, as they are dependent on the range type. It publicly inherits from the generic adaptor base class
• A class named as adaptors have been named so far, inheriting from the generic adaptor class with mlir::ValueRange as range to index into. It implements the rest of the API, specific to mlir::ValueRange adaptors, which have previously been part of the adaptor. This boils down to a constructor from the Op type as well as the verify function.

The last class having the exact same API surface and name as Adaptors did previously leads to full source compatibility.

[Mogball]

mlir/lib/TableGen/Class.cpp

284–286

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

1619

this seems like it should be a unit test

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

124

please document this parameter in the comment

1297

you don't need to annotate every argument name, typically only those whose value is a simple constant

1308

please spell out this auto

1312

and this one

1344

[zero9178]

Address review comments:

• Transform compile test to a unit tests that also checks that accessing operands works properly
• Fix style issues

[zero9178]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1297

I tried to find some sort of middle ground where I kept it for those, where the parameter name/meaning is not obvious from the argument passed to it, while removing it from those where it is arguably obvious. Hope this is okay

[jpienaar]

Overall looks nice

mlir/include/mlir/TableGen/Class.h

515

Could you add what each part means? That is how the params are encoded.

605

I feel this is more an implementation detail for correctness than a user facing item so I'd use a regular comment below rather than doxygen comment in function.

639

Why addMethod vs addMethodAndPrune?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1294

I think (but try and check) this will read easier if you hoist out a
bool isGenericAdaptorBase and then use an if-then-else rather than ternary operators inside the function invocation (this will also result in almost all parameters being documented by appropriate variable names (and then you could merge with conditional just below too).

Mmm, do you even use opClass is it is generic adaptor base in this function?

mlir/unittests/IR/AdaptorTest.cpp

25 ↗

(On Diff #486235)

Where is a used?

[zero9178]

address review comments

[zero9178]

mlir/include/mlir/TableGen/Class.h

515

I wasn't quite sure whether you meant, how the template prameters are "encoded" within the data structure, or whether you mean the template parameters chosen for SetVector (which I've admittedly just copy pasted from elsewhere). I've added a comment elaborating a bit on the former.

639

This just dispatches to the addMethod above, so ends up calling addMethodAndPrune, but also takes into account the additional logic for template parameters.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1294

Hoisting the bool definitely made it more readable, but I left it without and if for now, since I managed to reduce the ternary arguments to just the opClass parameter.
I moved the "special case" for the rangeSizeCall to within that functions implementation, where it makes a lot more sense, since that is also where the value used then as rangeSizeCall is defined.

mlir/unittests/IR/AdaptorTest.cpp

25 ↗

(On Diff #486235)

I added these more or less as "compile test" sanity checks, to force the compiler to instantiate the templates and catch any non-generic code that may have been generated by TableGen.

That said, they probably do not add a lot of value over the properly exercised ArrayRef<int> instantiations below, so I can remove these if you like

[zero9178]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1294

Also, the opClass is used below for generating all the getters for all the operands. This function call is the actual exception where the
proper getODSOperandIndexAndLength is generated in the non-templated base class. Both since it is a bigger bulk of the code, but also because its implementation may use the attribute name for operand_segment_sizes, which forms a circular dependency on the OpClass, hence needing to be in the cpp file (otherwise we'd have to move the adaptor generation below the class, which would be possible too I suppose)

[Mogball]

mlir/unittests/IR/AdaptorTest.cpp

64 ↗

(On Diff #486654)

newline pls

[zero9178]

Address review comments

• "newline pls" :-)

mlir/include/mlir/TableGen/Class.h

 /// this function is visible to `Class`.
 inline constexpr mlir::tblgen::Method::Properties
 operator|(mlir::tblgen::Method::Properties lhs,
           mlir::tblgen::Method::Properties rhs) {
   return mlir::tblgen::Method::Properties(static_cast<unsigned>(lhs) |
                                           static_cast<unsigned>(rhs));
 }
 
+inline constexpr mlir::tblgen::Method::Properties &
+operator|=(mlir::tblgen::Method::Properties &lhs,
+           mlir::tblgen::Method::Properties rhs) {
+  return lhs = mlir::tblgen::Method::Properties(static_cast<unsigned>(lhs) |
+                                                static_cast<unsigned>(rhs));
+}
+
 namespace mlir {
 namespace tblgen {
 
 /// This class describes a C++ parent class declaration.
 class ParentClass {
 public:
   /// Create a parent class with a class name and visibility.
   template <typename NameT>
public:
   template <typename NameT, typename ValueT = std::string>
   UsingDeclaration(NameT &&name, ValueT &&value = "")
       : name(stringify(std::forward<NameT>(name))),
         value(stringify(std::forward<ValueT>(value))) {}
 
   /// Write the using declaration.
   void writeDeclTo(raw_indented_ostream &os) const override;
 
+  /// Add a template parameter.
+  template <typename ParamT>
+  void addTemplateParam(ParamT param) {
+    templateParams.insert(stringify(param));
+  }
+
+  /// Add a list of template parameters.
+  template <typename ContainerT>
+  void addTemplateParams(ContainerT &&container) {
+    templateParams.insert(std::begin(container), std::end(container));
+  }
+
 private:
   /// The name of the declaration, or a resolved name to an inherited function.
   std::string name;
   /// The type that is being aliased. Leave empty for inheriting functions.
   std::string value;
+  /// An optional list of class template parameters.
+  SetVector<std::string, SmallVector<std::string>, StringSet<>> templateParams;
 };
 
 /// This class describes a class field.
 class Field : public ClassDeclarationBase<ClassDeclaration::Field> {
 public:
   /// Create a class field with a type and variable name.
   template <typename TypeT, typename NameT>
   Field(TypeT &&type, NameT &&name)
public:
   template <typename NameT,
             typename = std::enable_if_t<!std::is_same<NameT, Class>::value>>
   Class(NameT &&name, bool isStruct = false)
       : className(stringify(std::forward<NameT>(name))), isStruct(isStruct) {}
 
   /// Add a new constructor to this class and prune and constructors made
   /// redundant by it. Returns null if the constructor was not added. Else,
   /// returns a pointer to the new constructor.
+  /// If the class has template parameters, the constructor is automatically
+  /// defined inline.
   template <Method::Properties Properties = Method::None, typename... Args>
   Constructor *addConstructor(Args &&...args) {
+    Method::Properties defaultProperties = Method::Constructor;
+    if (!templateParams.empty())
+      defaultProperties |= Method::Inline;
     return addConstructorAndPrune(Constructor(getClassName(),
-                                              Properties | Method::Constructor,
+                                              Properties | defaultProperties,
                                               std::forward<Args>(args)...));
   }
 
   /// Add a new method to this class and prune any methods made redundant by it.
   /// Returns null if the method was not added (because an existing method would
   /// make it redundant). Else, returns a pointer to the new method.
+  /// If the class has template parameters, the method is automatically defined
+  /// inline.
+  template <Method::Properties Properties = Method::None, typename RetTypeT,
+            typename NameT>
+  Method *addMethod(RetTypeT &&retType, NameT &&name,
+                    Method::Properties properties,
+                    ArrayRef<MethodParameter> parameters) {
+    if (!templateParams.empty())
+      properties |= Method::Inline;
+    return addMethodAndPrune(Method(std::forward<RetTypeT>(retType),
+                                    std::forward<NameT>(name),
+                                    Properties | properties, parameters));
+  }
+
+  /// Add a method with statically-known properties.
+  template <Method::Properties Properties = Method::None, typename RetTypeT,
+            typename NameT>
+  Method *addMethod(RetTypeT &&retType, NameT &&name,
+                    ArrayRef<MethodParameter> parameters) {
+    return addMethod(std::forward<RetTypeT>(retType), std::forward<NameT>(name),
+                     Properties, parameters);
+  }
+
   template <Method::Properties Properties = Method::None, typename RetTypeT,
             typename NameT, typename... Args>
   Method *addMethod(RetTypeT &&retType, NameT &&name,
                     Method::Properties properties, Args &&...args) {
-    return addMethodAndPrune(
-        Method(std::forward<RetTypeT>(retType), std::forward<NameT>(name),
-               Properties | properties, std::forward<Args>(args)...));
+    return addMethod(std::forward<RetTypeT>(retType), std::forward<NameT>(name),
+                     properties | Properties, {std::forward<Args>(args)...});
   }
 
   /// Add a method with statically-known properties.
   template <Method::Properties Properties = Method::None, typename RetTypeT,
             typename NameT, typename... Args>
   Method *addMethod(RetTypeT &&retType, NameT &&name, Args &&...args) {
     return addMethod(std::forward<RetTypeT>(retType), std::forward<NameT>(name),
                      Properties, std::forward<Args>(args)...);
public:
   template <typename TypeT, typename NameT>
   void addField(TypeT &&type, NameT &&name) {
     fields.emplace_back(std::forward<TypeT>(type), std::forward<NameT>(name));
   }
 
   /// Add a parent class.
   ParentClass &addParent(ParentClass parent);
 
+  /// Add a template parameter.
+  template <typename ParamT>
+  void addTemplateParam(ParamT param) {
+    templateParams.insert(stringify(param));
+  }
+
+  /// Add a list of template parameters.
+  template <typename ContainerT>
+  void addTemplateParams(ContainerT &&container) {
+    templateParams.insert(std::begin(container), std::end(container));
+  }
+
   /// Return the C++ name of the class.
   StringRef getClassName() const { return className; }
 
   /// Write the declaration of this class, all declarations, and definitions of
   /// inline functions. Wrap the output stream in an indented stream.
   void writeDeclTo(raw_ostream &rawOs) const {
     raw_indented_ostream os(rawOs);
     writeDeclTo(os);
protected:
   std::vector<std::unique_ptr<Method>> methods;
   /// The pending list of private class fields.
   SmallVector<Field> fields;
   /// Whether this is a `class` or a `struct`.
   bool isStruct;
 
   /// A list of declarations in the class, emitted in order.
   std::vector<std::unique_ptr<ClassDeclaration>> declarations;
+
+  /// An optional list of class template parameters.
+  SetVector<std::string, SmallVector<std::string>, StringSet<>> templateParams;
 };
 
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_CLASS_H_

mlir/include/mlir/TableGen/Operator.h

public:
   std::string getQualCppClassName() const;
 
   /// Returns this op's C++ namespace.
   StringRef getCppNamespace() const;
 
   /// Returns the name of op's adaptor C++ class.
   std::string getAdaptorName() const;
 
+  /// Returns the name of op's generic adaptor C++ class.
+  std::string getGenericAdaptorName() const;
+
   /// Check invariants (like no duplicated or conflicted names) and abort the
   /// process if any invariant is broken.
   void assertInvariants() const;
 
   /// A class used to represent the decorators of an operator variable, i.e.
   /// argument or result.
   struct VariableDecorator {
   public:

mlir/lib/TableGen/Class.cpp

void ParentClass::writeTo(raw_indented_ostream &os) const {
   }
 }
 
 //===----------------------------------------------------------------------===//
 // UsingDeclaration definitions
 //===----------------------------------------------------------------------===//
 
 void UsingDeclaration::writeDeclTo(raw_indented_ostream &os) const {
+  if (!templateParams.empty()) {
+    os << "template <";
+    llvm::interleaveComma(templateParams, os, [&](StringRef paramName) {
+      os << "typename " << paramName;
+    });
+    os << ">\n";
+  }
   os << "using " << name;
   if (!value.empty())
     os << " = " << value;
   os << ";\n";
 }
 
 //===----------------------------------------------------------------------===//
 // Field definitions

 // Class definitions
 //===----------------------------------------------------------------------===//
 
 ParentClass &Class::addParent(ParentClass parent) {
   parents.push_back(std::move(parent));
   return parents.back();
 }
 
 void Class::writeDeclTo(raw_indented_ostream &os) const {
+
+  if (!templateParams.empty()) {
+    os << "template <";
+    llvm::interleaveComma(templateParams, os,
+                          [&](StringRef param) { os << "typename " << param; });
+    os << ">\n";
+  }
+
   // Declare the class.
   os << (isStruct ? "struct" : "class") << ' ' << className << ' ';
 
   // Declare the parent classes, if any.
   if (!parents.empty()) {
     os << ": ";
     llvm::interleaveComma(parents, os,
                           [&](auto &parent) { parent.writeTo(os); });

 
 Visibility Class::getLastVisibilityDecl() const {
   auto reverseDecls = llvm::reverse(declarations);
   auto it = llvm::find_if(reverseDecls, [](auto &decl) {
     return isa<VisibilityDeclaration>(decl);
   });
   return it == reverseDecls.end()
              ? (isStruct ? Visibility::Public : Visibility::Private)
-             : cast<VisibilityDeclaration>(*it).getVisibility();
+             : cast<VisibilityDeclaration>(**it).getVisibility();
 }
 
 Method *insertAndPruneMethods(std::vector<std::unique_ptr<Method>> &methods,
                               std::unique_ptr<Method> newMethod) {
   if (llvm::any_of(methods, [&](auto &method) {
         return method->makesRedundant(*newMethod);
       }))
     return nullptr;

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()));
 }
 
+std::string Operator::getGenericAdaptorName() const {
+  return std::string(llvm::formatv("{0}GenericAdaptor", 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.
   //

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

void TestReflectBoundsOp::inferResultRanges(
   Builder b(ctx);
   setUminAttr(b.getIndexAttr(range.umin().getZExtValue()));
   setUmaxAttr(b.getIndexAttr(range.umax().getZExtValue()));
   setSminAttr(b.getIndexAttr(range.smin().getSExtValue()));
   setSmaxAttr(b.getIndexAttr(range.smax().getSExtValue()));
   setResultRanges(getResult(), range);
 }
 
+[[maybe_unused]] static void
+genericAdaptorsTemplateInstantiationCompileTests() {
+  // Has normal and Variadic arguments.
+  MixedNormalVariadicOperandOp::FoldAdaptor a({});
+  MixedNormalVariadicOperandOp::GenericAdaptor<ArrayRef<int *>> b({});
+  // Has optional arguments.
+  OIListSimple::FoldAdaptor c({});
+  OIListSimple::GenericAdaptor<ArrayRef<int *>> d({});
+  // Has VariadicOfVariadic arguments.
+  FormatVariadicOfVariadicOperand::FoldAdaptor e({});
+  FormatVariadicOfVariadicOperand::GenericAdaptor<ArrayRef<int *>> f({});
+}
+
 #include "TestOpEnums.cpp.inc"
 #include "TestOpInterfaces.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

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

def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
   let extraClassDeclaration = [{
     // Display a graph for debugging purposes.
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations
 
-// CHECK: class AOpAdaptor {
+// CHECK: namespace detail {
+// CHECK: class AOpGenericAdaptorBase {
 // CHECK: public:
-// CHECK:   AOpAdaptor(::mlir::ValueRange values
-// CHECK:   ::mlir::ValueRange getODSOperands(unsigned index);
-// CHECK:   ::mlir::Value getA();
-// CHECK:   ::mlir::ValueRange getB();
 // CHECK:   ::mlir::IntegerAttr getAttr1Attr();
 // CHECK:   uint32_t getAttr1();
 // CHECK:   ::mlir::FloatAttr getSomeAttr2Attr();
 // CHECK:   ::std::optional< ::llvm::APFloat > getSomeAttr2();
 // CHECK:   ::mlir::Region &getSomeRegion();
 // CHECK:   ::mlir::RegionRange getSomeRegions();
+// CHECK: };
+// CHECK: }
+
+// CHECK: template <typename RangeT>
+// CHECK: class AOpGenericAdaptor : public detail::AOpGenericAdaptorBase {
+// CHECK: public:
+// CHECK:   AOpGenericAdaptor(RangeT values,
+// CHECK-SAME: odsOperands(values)
+// CHECK:   RangeT getODSOperands(unsigned index) {
+// CHECK:   ValueT getA() {
+// CHECK:   RangeT getB() {
 // CHECK: private:
-// CHECK:   ::mlir::ValueRange odsOperands;
+// CHECK:   RangeT odsOperands;
+// CHECK: };
+
+// CHECK: class AOpAdaptor : public AOpGenericAdaptor<::mlir::ValueRange> {
+// CHECK: public:
+// CHECK:   AOpAdaptor(AOp
+// CHECK:   ::mlir::LogicalResult verify(
 // CHECK: };
 
 // CHECK: class AOp : public ::mlir::Op<AOp, ::mlir::OpTrait::AtLeastNRegions<1>::Impl, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsIsolatedFromAbove
 // CHECK-NOT: ::mlir::OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using Adaptor = AOpAdaptor;
 // CHECK:   static constexpr ::llvm::StringLiteral getOperationName() {

 // CHECK:   static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
 // 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::getSomeRegions()
+// DEFS: AOpGenericAdaptorBase::AOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsAttrs(attrs), odsRegions(regions)
+// DEFS: ::mlir::RegionRange AOpGenericAdaptorBase::getSomeRegions()
 // DEFS-NEXT: return odsRegions.drop_front(1);
-// DEFS: ::mlir::RegionRange AOpAdaptor::getRegions()
+// DEFS: ::mlir::RegionRange AOpGenericAdaptorBase::getRegions()
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,
     I32:$c,
     Variadic<I32>:$d,
     I32ElementsAttr:$operand_segment_sizes
   );
 }
 
-// CHECK-LABEL: AttrSizedOperandOpAdaptor(
-// CHECK-SAME:    ::mlir::ValueRange values
-// CHECK-SAME:    ::mlir::DictionaryAttr attrs
-// CHECK:  ::mlir::ValueRange getA();
-// CHECK:  ::mlir::ValueRange getB();
-// CHECK:  ::mlir::Value getC();
-// CHECK:  ::mlir::ValueRange getD();
+// CHECK-LABEL: class AttrSizedOperandOpGenericAdaptorBase {
 // CHECK:  ::mlir::DenseIntElementsAttr getOperandSegmentSizes();
 
+// CHECK-LABEL: AttrSizedOperandOpGenericAdaptor(
+// CHECK-SAME:    RangeT values
+// CHECK-SAME:    ::mlir::DictionaryAttr attrs
+// CHECK:  RangeT getA() {
+// CHECK:  RangeT getB() {
+// CHECK:  ValueT getC() {
+// CHECK:  RangeT getD() {
+
 // Check op trait for different number of operands
 // ---
 
 def NS_BOp : NS_Op<"op_with_no_operand", []> {
   let arguments = (ins);
 }
 
 // CHECK-LABEL: NS::BOp declarations

 // CHECK: OpTrait::NOperands<2>::Impl
 
 def NS_EOp : NS_Op<"op_with_optionals", []> {
   let arguments = (ins Optional<I32>:$a);
   let results = (outs Optional<F32>:$b);
 }
 
 // CHECK-LABEL: NS::EOp declarations
-// CHECK:   ::mlir::Value getA();
+// CHECK:   ::mlir::TypedValue<::mlir::IntegerType> getA();
 // CHECK:   ::mlir::MutableOperandRange getAMutable();
 // CHECK:   ::mlir::TypedValue<::mlir::FloatType> getB();
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type b, /*optional*/::mlir::Value a)
 
 // Check that all types match constraint results in generating builder.
 // ---
 
 def NS_FOp : NS_Op<"op_with_all_types_constraint",

 // CHECK-LABEL: NS::SkipDefaultBuildersOp declarations
 // CHECK:     class SkipDefaultBuildersOp
 // CHECK-NOT:   static void build(::mlir::Builder
 // CHECK:       static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value
 
 // Check leading underscore in op name
 // ---
 
+def NS_VarOfVarOperandOp : NS_Op<"var_of_var_operand", []> {
+  let arguments = (ins
+    VariadicOfVariadic<F32, "var_size">:$var_of_var_attr,
+    DenseI32ArrayAttr:$var_size
+  );
+}
+
+// CHECK-LABEL: class VarOfVarOperandOpGenericAdaptor
+// CHECK: public:
+// CHECK: ::llvm::SmallVector<RangeT> getVarOfVarAttr() {
+
+
 def NS__AOp : NS_Op<"_op_with_leading_underscore", []>;
 
 // CHECK-LABEL: NS::_AOp declarations
 // CHECK: class _AOp : public ::mlir::Op<_AOp
 
 def _BOp : NS_Op<"_op_with_leading_underscore_and_no_namespace", []>;
 
 // CHECK-LABEL: _BOp declarations
 // CHECK: class _BOp : public ::mlir::Op<_BOp
 
 // REDUCE_INC-LABEL: NS::AOp declarations
 // REDUCE_INC-NOT: NS::BOp declarations
 
 // REDUCE_EXC-NOT: NS::AOp declarations
 // REDUCE_EXC-LABEL: NS::BOp declarations

mlir/test/mlir-tblgen/op-operand.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def OpA : NS_Op<"one_normal_operand_op", []> {
   let arguments = (ins I32:$input);
 }
 
 // CHECK-LABEL: OpA definitions
 
-// CHECK:      OpAAdaptor::OpAAdaptor
-// CHECK-SAME: odsOperands(values), odsAttrs(attrs)
+// CHECK:      OpAGenericAdaptorBase::OpAGenericAdaptorBase
+// CHECK-SAME: odsAttrs(attrs)
 
 // CHECK:      void OpA::build
 // CHECK:        ::mlir::Value input
 // CHECK:        odsState.addOperands(input);
 
 // CHECK:      void OpA::build
 // CHECK:        ::mlir::ValueRange operands
 // CHECK:        assert(operands.size() == 1u && "mismatched number of parameters");
 // CHECK:        odsState.addOperands(operands);
 
 def OpB : NS_Op<"one_variadic_operand_op", []> {
   let arguments = (ins Variadic<I32>:$input);
 }
 
 // CHECK-LABEL: OpB::build
 // CHECK:         ::mlir::ValueRange input
 // CHECK-NOT:     assert
 // CHECK:         odsState.addOperands(input);
 
 def OpD : NS_Op<"mix_variadic_and_normal_inputs_op", [SameVariadicOperandSize]> {
   let arguments = (ins Variadic<AnyTensor>:$input1, AnyTensor:$input2, Variadic<AnyTensor>:$input3);
 }
 
-// CHECK-LABEL: ::mlir::ValueRange OpDAdaptor::getInput1
-// CHECK-NEXT:    return getODSOperands(0);
-
-// CHECK-LABEL: ::mlir::Value OpDAdaptor::getInput2
-// CHECK-NEXT:    return *getODSOperands(1).begin();
-
-// CHECK-LABEL: ::mlir::ValueRange OpDAdaptor::getInput3
-// CHECK-NEXT:    return getODSOperands(2);
-
 // CHECK-LABEL: ::mlir::Operation::operand_range OpD::getInput1
 // CHECK-NEXT: return getODSOperands(0);
 
 // CHECK-LABEL: ::mlir::TypedValue<::mlir::TensorType> OpD::getInput2
 // CHECK-NEXT: return *getODSOperands(1).begin();
 
 // CHECK-LABEL: OpD::build
 // CHECK-NEXT: odsState.addOperands(input1);
 // CHECK-NEXT: odsState.addOperands(input2);
 // CHECK-NEXT: odsState.addOperands(input3);

mlir/tools/mlir-tblgen/OpClass.cpp

: Class(name.str()), extraClassDeclaration(extraClassDeclaration),
       parent(addParent("::mlir::Op")) {
   parent.addTemplateParam(getClassName().str());
   declare<VisibilityDeclaration>(Visibility::Public);
   /// Inherit functions from Op.
   declare<UsingDeclaration>("Op::Op");
   declare<UsingDeclaration>("Op::print");
   /// Type alias for the adaptor class.
   declare<UsingDeclaration>("Adaptor", className + "Adaptor");
+  declare<UsingDeclaration>("GenericAdaptor",
+                            className + "GenericAdaptor<RangeT>")
+      ->addTemplateParam("RangeT");
+  declare<UsingDeclaration>(
+      "FoldAdaptor", "GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>");
 }
 
 void OpClass::finalize() {
   Class::finalize();
   declare<VisibilityDeclaration>(Visibility::Public);
   declare<ExtraClassDeclaration>(extraClassDeclaration, extraClassDefinition);
 }

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 /// of an op with variadic of variadic operands within the OpAdaptor.
 ///
 /// {0}: The name of the segment attribute.
 /// {1}: The index of the main operand.
 static const char *const variadicOfVariadicAdaptorCalcCode = R"(
   auto tblgenTmpOperands = getODSOperands({1});
   auto sizes = {0}();
 
-  ::llvm::SmallVector<::mlir::ValueRange> tblgenTmpOperandGroups;
+  ::llvm::SmallVector<{2}> tblgenTmpOperandGroups;
   for (int i = 0, e = sizes.size(); i < e; ++i) {{
     tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i]));
     tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]);
   }
   return tblgenTmpOperandGroups;
 )";
 
 /// The logic to build a range of either operand or result values.
void OpEmitter::genOptionalAttrRemovers() {
   for (const NamedAttribute &namedAttr : op.getAttributes())
     if (namedAttr.attr.isOptional())
       emitRemoveAttr(namedAttr.name);
 }
 
 // Generates the code to compute the start and end index of an operand or result
 // range.
 template <typename RangeT>
-static void
-generateValueRangeStartAndEnd(Class &opClass, StringRef methodName,
-                              int numVariadic, int numNonVariadic,
-                              StringRef rangeSizeCall, bool hasAttrSegmentSize,
-                              StringRef sizeAttrInit, RangeT &&odsValues) {
+static void generateValueRangeStartAndEnd(
+    Class &opClass, bool isGenericAdaptorBase, StringRef methodName,
+    int numVariadic, int numNonVariadic, StringRef rangeSizeCall,
+    bool hasAttrSegmentSize, StringRef sizeAttrInit, RangeT &&odsValues) {
+
+  SmallVector<MethodParameter> parameters{MethodParameter("unsigned", "index")};
+  if (isGenericAdaptorBase)
+    parameters.emplace_back("unsigned", "odsOperandsSize");
+
   auto *method = opClass.addMethod("std::pair<unsigned, unsigned>", methodName,
-                                   MethodParameter("unsigned", "index"));
+                                   parameters);
   if (!method)
     return;
   auto &body = method->body();
   if (numVariadic == 0) {
     body << "  return {index, 1};\n";
   } else if (hasAttrSegmentSize) {
     body << sizeAttrInit << attrSizedSegmentValueRangeCalcCode;
   } else {
     // Because the op can have arbitrarily interleaved variadic and non-variadic
     // operands, we need to embed a list in the "sink" getter method for
     // calculation at run-time.
     SmallVector<StringRef, 4> isVariadic;
     isVariadic.reserve(llvm::size(odsValues));
     for (auto &it : odsValues)
       isVariadic.push_back(it.isVariableLength() ? "true" : "false");
     std::string isVariadicList = llvm::join(isVariadic, ", ");
     body << formatv(sameVariadicSizeValueRangeCalcCode, isVariadicList,
                     numNonVariadic, numVariadic, rangeSizeCall, "operand");
   }
 }
 
-static std::string generateTypeForGetter(bool isAdaptor,
-                                         const NamedTypeConstraint &value) {
+static std::string generateTypeForGetter(const NamedTypeConstraint &value) {
   std::string str = "::mlir::Value";
   /// If the CPPClassName is not a fully qualified type. Uses of types
   /// across Dialect fail because they are not in the correct namespace. So we
   /// dont generate TypedValue unless the type is fully qualified.
   /// getCPPClassName doesn't return the fully qualified path for
   /// `mlir::pdl::OperationType` see
   /// https://github.com/llvm/llvm-project/issues/57279.
   /// Adaptor will have values that are not from the type of their operation and
   /// this is expected, so we dont generate TypedValue for Adaptor
-  if (!isAdaptor && value.constraint.getCPPClassName() != "::mlir::Type" &&
+  if (value.constraint.getCPPClassName() != "::mlir::Type" &&
       StringRef(value.constraint.getCPPClassName()).startswith("::"))
     str = llvm::formatv("::mlir::TypedValue<{0}>",
                         value.constraint.getCPPClassName())
               .str();
   return str;
 }
 
 // Generates the named operand getter methods for the given Operator `op` and
 // puts them in `opClass`.  Uses `rangeType` as the return type of getters that
 // return a range of operands (individual operands are `Value ` and each
 // element in the range must also be `Value `); use `rangeBeginCall` to get
 // an iterator to the beginning of the operand range; use `rangeSizeCall` to
 // obtain the number of operands. `getOperandCallPattern` contains the code
 // necessary to obtain a single operand whose position will be substituted
 // instead of
 // "{0}" marker in the pattern.  Note that the pattern should work for any kind
 // of ops, in particular for one-operand ops that may not have the
 // `getOperand(unsigned)` method.
-static void generateNamedOperandGetters(const Operator &op, Class &opClass,
-                                        bool isAdaptor, StringRef sizeAttrInit,
-                                        StringRef rangeType,
-                                        StringRef rangeBeginCall,
-                                        StringRef rangeSizeCall,
-                                        StringRef getOperandCallPattern) {
+static void
+generateNamedOperandGetters(const Operator &op, Class &opClass,
+                            Class *genericAdaptorBase, StringRef sizeAttrInit,
+                            StringRef rangeType, StringRef rangeElementType,
+                            StringRef rangeBeginCall, StringRef rangeSizeCall,
   const int numOperands = op.getNumOperands();
   const int numVariadicOperands = op.getNumVariableLengthOperands();
   const int numNormalOperands = numOperands - numVariadicOperands;
 
   const auto *sameVariadicSize =
       op.getTrait("::mlir::OpTrait::SameVariadicOperandSize");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
generateNamedOperandGetters(const Operator &op, Class &opClass,
   if (attrSizedOperands && sameVariadicSize) {
     PrintFatalError(op.getLoc(),
                     "op cannot have both 'AttrSizedOperandSegments' and "
                     "'SameVariadicOperandSize' traits");
   }
 
   // First emit a few "sink" getter methods upon which we layer all nicer named
   // getter methods.
-  generateValueRangeStartAndEnd(opClass, "getODSOperandIndexAndLength",
-                                numVariadicOperands, numNormalOperands,
-                                rangeSizeCall, attrSizedOperands, sizeAttrInit,
-                                const_cast<Operator &>(op).getOperands());
+  // If generating for an adaptor, the method is put into the non-templated
+  // generic base class, to not require being defined in the header.
+  // Since the operand size can't be determined from the base class however,
+  // it has to be passed as an additional argument. The trampoline below
+  // generates the function with the same signature as the Op in the generic
+  // adaptor.
+  generateValueRangeStartAndEnd(
+      /*opClass=*/genericAdaptorBase != nullptr ? *genericAdaptorBase : opClass,
+      /*isGenericAdaptorBase=*/genericAdaptorBase != nullptr,
+      /*methodName=*/"getODSOperandIndexAndLength",
+      /*numVariadic=*/numVariadicOperands,
+      /*numNonVariadic=*/numNormalOperands,
+      /*rangeSizeCall=*/genericAdaptorBase != nullptr ? "odsOperandsSize"
+                                                      : rangeSizeCall,
+      /*hasAttrSegmentSize=*/attrSizedOperands,
+      /*sizeAttrInit=*/sizeAttrInit,
+      /*odsValues=*/const_cast<Operator &>(op).getOperands());
+  if (genericAdaptorBase) {
+    // Generate trampoline for calling 'getODSOperandIndexAndLength' with just
+    // the index. This just calls the implementation in the base class but
+    // passes the operand size as parameter.
+    auto *method = opClass.addMethod("std::pair<unsigned, unsigned>",
+                                     "getODSOperandIndexAndLength",
+                                     MethodParameter("unsigned", "index"));
+    ERROR_IF_PRUNED(method, "getODSOperandIndexAndLength", op);
+    auto &body = method->body();
+    body.indent() << formatv(
+        "return Base::getODSOperandIndexAndLength(index, {0});", rangeSizeCall);
+  }
 
   auto *m = opClass.addMethod(rangeType, "getODSOperands",
                               MethodParameter("unsigned", "index"));
   ERROR_IF_PRUNED(m, "getODSOperands", op);
   auto &body = m->body();
   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;
     std::string name = op.getGetterName(operand.name);
     if (operand.isOptional()) {
-      m = opClass.addMethod(generateTypeForGetter(isAdaptor, operand), name);
+      m = opClass.addMethod(genericAdaptorBase != nullptr
+                                ? rangeElementType
+                                : generateTypeForGetter(operand),
+                            name);
       ERROR_IF_PRUNED(m, name, op);
-      m->body() << "  auto operands = getODSOperands(" << i << ");\n"
-                << "  return operands.empty() ? ::mlir::Value() : "
-                   "*operands.begin();";
+      m->body().indent() << formatv(
+          "auto operands = getODSOperands({0});\n"
+          "return operands.empty() ? {1}{{} : *operands.begin();",
+          i, rangeElementType);
     } else if (operand.isVariadicOfVariadic()) {
       std::string segmentAttr = op.getGetterName(
           operand.constraint.getVariadicOfVariadicSegmentSizeAttr());
-      if (isAdaptor) {
-        m = opClass.addMethod("::llvm::SmallVector<::mlir::ValueRange>", name);
+      if (genericAdaptorBase != nullptr) {
+        m = opClass.addMethod("::llvm::SmallVector<" + rangeType + ">", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << llvm::formatv(variadicOfVariadicAdaptorCalcCode,
-                                   segmentAttr, i);
+                                   segmentAttr, i, rangeType);
         continue;
       }
 
       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);
+      m = opClass.addMethod(genericAdaptorBase != nullptr
+                                ? rangeElementType
+                                : generateTypeForGetter(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_size)s
   // array.
   std::string attrSizeInitCode;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
                                emitHelper.getAttr(operandSegmentAttrName));
   }
 
   generateNamedOperandGetters(
       op, opClass,
-      /*isAdaptor=*/false,
+      /*genericAdaptorBase=*/nullptr,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
+      /*rangeElementType=*/"::mlir::Value",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
       /*rangeSizeCall=*/"getOperation()->getNumOperands()",
       /*getOperandCallPattern=*/"getOperation()->getOperand({0})");
 }
 
 void OpEmitter::genNamedOperandSetters() {
   auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
void OpEmitter::genNamedResultGetters() {
   // Build the initializer string for the result segment size attribute.
   std::string attrSizeInitCode;
   if (attrSizedResults) {
     attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
                                emitHelper.getAttr(resultSegmentAttrName));
   }
 
   generateValueRangeStartAndEnd(
-      opClass, "getODSResultIndexAndLength", numVariadicResults,
-      numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
-      attrSizeInitCode, op.getResults());
+      opClass, /*isGenericAdaptorBase=*/false, "getODSResultIndexAndLength",
+      numVariadicResults, numNormalResults, "getOperation()->getNumResults()",
+      attrSizedResults, attrSizeInitCode, op.getResults());
 
   auto *m =
       opClass.addMethod("::mlir::Operation::result_range", "getODSResults",
                         MethodParameter("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;
     std::string name = op.getGetterName(result.name);
     if (result.isOptional()) {
-      m = opClass.addMethod(generateTypeForGetter(/*isAdaptor=*/false, result),
-                            name);
+      m = opClass.addMethod(generateTypeForGetter(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);
+      m = opClass.addMethod(generateTypeForGetter(result), name);
       ERROR_IF_PRUNED(m, name, op);
       m->body() << "  return *getODSResults(" << i << ").begin();";
     }
   }
 }
 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();

 }
 
 //===----------------------------------------------------------------------===//
 // OpOperandAdaptor emitter
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Helper class to emit Op operand adaptors to an output stream.  Operand
-// adaptors are wrappers around ArrayRef<Value> that provide named operand
+// adaptors are wrappers around random access ranges that provide named operand
 // getters identical to those defined in the Op.
+// This currently generates 3 classes per Op:
+// * A Base class within the 'detail' namespace, which contains all logic and
+//   members independent of the random access range that is indexed into.
+//   In other words, it contains all the attribute and region getters.
+// * A templated class named '{OpName}GenericAdaptor' with a template parameter
+//   'RangeT' that is indexed into by the getters to access the operands.
+//   It contains all getters to access operands and inherits from the previous
+//   class.
+// * A class named '{OpName}Adaptor', which inherits from the 'GenericAdaptor'
+//   with 'mlir::ValueRange' as template parameter. It adds a constructor from
+//   an instance of the op type and a verify function.
 class OpOperandAdaptorEmitter {
 public:
   static void
   emitDecl(const Operator &op,
            const StaticVerifierFunctionEmitter &staticVerifierEmitter,
            raw_ostream &os);
   static void
   emitDef(const Operator &op,
           const StaticVerifierFunctionEmitter &staticVerifierEmitter,
           raw_ostream &os);
 
 private:
   explicit OpOperandAdaptorEmitter(
       const Operator &op,
       const StaticVerifierFunctionEmitter &staticVerifierEmitter);
 
   // Add verification function. This generates a verify method for the adaptor
   // which verifies all the op-independent attribute constraints.
   void addVerification();
 
   // The operation for which to emit an adaptor.
   const Operator &op;
 
-  // The generated adaptor class.
+  // The generated adaptor classes.
+  Class genericAdaptorBase;
+  Class genericAdaptor;
   Class adaptor;
 
   // The emitter containing all of the locally emitted verification functions.
   const StaticVerifierFunctionEmitter &staticVerifierEmitter;
 
   // Helper for emitting adaptor code.
   OpOrAdaptorHelper emitHelper;
 };
 } // namespace
 
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(
     const Operator &op,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter)
-    : op(op), adaptor(op.getAdaptorName()),
+    : op(op), genericAdaptorBase(op.getGenericAdaptorName() + "Base"),
+      genericAdaptor(op.getGenericAdaptorName()), adaptor(op.getAdaptorName()),
       staticVerifierEmitter(staticVerifierEmitter),
       emitHelper(op, /*emitForOp=*/false) {
-  adaptor.addField("::mlir::ValueRange", "odsOperands");
-  adaptor.addField("::mlir::DictionaryAttr", "odsAttrs");
-  adaptor.addField("::mlir::RegionRange", "odsRegions");
-  adaptor.addField("::std::optional<::mlir::OperationName>", "odsOpName");
+
+  genericAdaptorBase.declare<VisibilityDeclaration>(Visibility::Protected);
+  genericAdaptorBase.declare<Field>("::mlir::DictionaryAttr", "odsAttrs");
+  genericAdaptorBase.declare<Field>("::mlir::RegionRange", "odsRegions");
+  genericAdaptorBase.declare<Field>("::std::optional<::mlir::OperationName>",
+                                    "odsOpName");
+
+  genericAdaptor.addTemplateParam("RangeT");
+  genericAdaptor.addField("RangeT", "odsOperands");
+  genericAdaptor.addParent(
+      ParentClass("detail::" + genericAdaptorBase.getClassName()));
+  genericAdaptor.declare<UsingDeclaration>(
+      "ValueT", "::llvm::detail::ValueOfRange<RangeT>");
+  genericAdaptor.declare<UsingDeclaration>(
+      "Base", "detail::" + genericAdaptorBase.getClassName());
 
   const auto *attrSizedOperands =
       op.getTrait("::m::OpTrait::AttrSizedOperandSegments");
   {
     SmallVector<MethodParameter> paramList;
-    paramList.emplace_back("::mlir::ValueRange", "values");
     paramList.emplace_back("::mlir::DictionaryAttr", "attrs",
                            attrSizedOperands ? "" : "nullptr");
     paramList.emplace_back("::mlir::RegionRange", "regions", "{}");
-    auto *constructor = adaptor.addConstructor(std::move(paramList));
-
-    constructor->addMemberInitializer("odsOperands", "values");
-    constructor->addMemberInitializer("odsAttrs", "attrs");
-    constructor->addMemberInitializer("odsRegions", "regions");
+    auto *baseConstructor = genericAdaptorBase.addConstructor(paramList);
+    baseConstructor->addMemberInitializer("odsAttrs", "attrs");
+    baseConstructor->addMemberInitializer("odsRegions", "regions");
 
-    MethodBody &body = constructor->body();
+    MethodBody &body = baseConstructor->body();
     body.indent() << "if (odsAttrs)\n";
     body.indent() << formatv(
         "odsOpName.emplace(\"{0}\", odsAttrs.getContext());\n",
         op.getOperationName());
-  }
 
-  {
-    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()");
+    paramList.insert(paramList.begin(), MethodParameter("RangeT", "values"));
+    auto *constructor = genericAdaptor.addConstructor(std::move(paramList));
+    constructor->addMemberInitializer("Base", "attrs, regions");
+    constructor->addMemberInitializer("odsOperands", "values");
   }
 
   std::string sizeAttrInit;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode,
                            emitHelper.getAttr(operandSegmentAttrName));
   }
-  generateNamedOperandGetters(op, adaptor,
-                              /*isAdaptor=*/true, sizeAttrInit,
-                              /*rangeType=*/"::mlir::ValueRange",
+  generateNamedOperandGetters(op, genericAdaptor,
+                              /*genericAdaptorBase=*/&genericAdaptorBase,
+                              /*sizeAttrInit=*/sizeAttrInit,
+                              /*rangeType=*/"RangeT",
+                              /*rangeElementType=*/"ValueT",
                               /*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"))
+  if (auto *m = genericAdaptor.addMethod("RangeT", "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");
+    auto *method =
+        genericAdaptorBase.addMethod(attr.getStorageType(), emitName + "Attr");
     ERROR_IF_PRUNED(method, "Adaptor::" + emitName + "Attr", op);
     auto &body = method->body().indent();
     body << "assert(odsAttrs && \"no attributes when constructing adapter\");\n"
          << formatv("auto attr = {0}.{1}<{2}>();\n", emitHelper.getAttr(name),
                     attr.hasDefaultValue() || attr.isOptional()
                         ? "dyn_cast_or_null"
                         : "cast",
                     attr.getStorageType());
 
     if (attr.hasDefaultValue() && attr.isOptional()) {
       // Use the default value if attribute is not set.
       // TODO: this is inefficient, we are recreating the attribute for every
       // call. This should be set instead.
       std::string defaultValue = std::string(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
       body << "if (!attr)\n  attr = " << defaultValue << ";\n";
     }
     body << "return attr;\n";
   };
 
   {
-    auto *m = adaptor.addMethod("::mlir::DictionaryAttr", "getAttributes");
+    auto *m =
+        genericAdaptorBase.addMethod("::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())
       continue;
     std::string emitName = op.getGetterName(name);
     emitAttrWithStorageType(name, emitName, attr);
-    emitAttrGetterWithReturnType(fctx, adaptor, op, emitName, attr);
+    emitAttrGetterWithReturnType(fctx, genericAdaptorBase, op, emitName, attr);
   }
 
   unsigned numRegions = op.getNumRegions();
   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.
     std::string name = op.getGetterName(region.name);
     if (region.isVariadic()) {
-      auto *m = adaptor.addMethod("::mlir::RegionRange", name);
+      auto *m = genericAdaptorBase.addMethod("::mlir::RegionRange", name);
       ERROR_IF_PRUNED(m, "Adaptor::" + name, op);
       m->body() << formatv("  return odsRegions.drop_front({0});", i);
       continue;
     }
 
-    auto *m = adaptor.addMethod("::mlir::Region &", name);
+    auto *m = genericAdaptorBase.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"))
+    if (auto *m =
+            genericAdaptorBase.addMethod("::mlir::RegionRange", "getRegions"))
       m->body() << "  return odsRegions;";
   }
 
+  StringRef genericAdaptorClassName = genericAdaptor.getClassName();
+  adaptor.addParent(ParentClass(genericAdaptorClassName))
+      .addTemplateParam("::mlir::ValueRange");
+  adaptor.declare<VisibilityDeclaration>(Visibility::Public);
+  adaptor.declare<UsingDeclaration>(genericAdaptorClassName +
+                                    "::" + genericAdaptorClassName);
+  {
+    // Constructor taking the Op as single parameter.
+    auto *constructor =
+        adaptor.addConstructor(MethodParameter(op.getCppClassName(), "op"));
+    constructor->addMemberInitializer(
+        adaptor.getClassName(),
+        "op->getOperands(), op->getAttrDictionary(), op->getRegions()");
+  }
+
   // Add verification function.
   addVerification();
+
+  genericAdaptorBase.finalize();
+  genericAdaptor.finalize();
   adaptor.finalize();
 }
 
 void OpOperandAdaptorEmitter::addVerification() {
   auto *method = adaptor.addMethod("::mlir::LogicalResult", "verify",
                                    MethodParameter("::mlir::Location", "loc"));
   ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
 
   FmtContext verifyCtx;
   populateSubstitutions(emitHelper, verifyCtx);
   genAttributeVerifier(emitHelper, verifyCtx, body, staticVerifierEmitter);
 
   body << "  return ::mlir::success();";
 }
 
 void OpOperandAdaptorEmitter::emitDecl(
     const Operator &op,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter,
     raw_ostream &os) {
-  OpOperandAdaptorEmitter(op, staticVerifierEmitter).adaptor.writeDeclTo(os);
+  OpOperandAdaptorEmitter emitter(op, staticVerifierEmitter);
+  {
+    NamespaceEmitter ns(os, "detail");
+    emitter.genericAdaptorBase.writeDeclTo(os);
+  }
+  emitter.genericAdaptor.writeDeclTo(os);
+  emitter.adaptor.writeDeclTo(os);
 }
 
 void OpOperandAdaptorEmitter::emitDef(
     const Operator &op,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter,
     raw_ostream &os) {
-  OpOperandAdaptorEmitter(op, staticVerifierEmitter).adaptor.writeDefTo(os);
+  OpOperandAdaptorEmitter emitter(op, staticVerifierEmitter);
+  {
+    NamespaceEmitter ns(os, "detail");
+    emitter.genericAdaptorBase.writeDefTo(os);
+  }
+  emitter.genericAdaptor.writeDefTo(os);
+  emitter.adaptor.writeDefTo(os);
 }
 
 // Emits the opcode enum and op classes.
 static void emitOpClasses(const RecordKeeper &recordKeeper,
                           const std::vector<Record *> &defs, raw_ostream &os,
                           bool emitDecl) {
   // First emit forward declaration for each class, this allows them to refer
   // to each others in traits for example.