[mlir] Use ValueRange instead of ArrayRef<Value> in adaptor

[jpienaar]

Summary

This allows constructing an operand adaptor from existing op (useful for commonalizing verification as I want to do in a follow up). ValueRange also allows the same code to be used in more instances.

I also addied the ability to use member initializers for the generated adaptor constructors for convenience. It was required for a different version of this but not essential for this one (just matches closer to how one would write the code that is being generated) so I could split it out.

[silvas]

Nice! I'm really looking forward to this line of work unifying the adaptors with the main flow :)

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

public:
   // appear in load/store operations and memref type declarations.
   Value linearizeSubscripts(ConversionPatternRewriter &builder, Location loc,
                             ArrayRef<Value> indices,
                             ArrayRef<Value> allocSizes) const;
 
   // This is a strided getElementPtr variant that linearizes subscripts as:
   //   `base_offset + index_0 * stride_0 + ... + index_n * stride_n`.
   Value getStridedElementPtr(Location loc, Type elementTypePtr,
-                             Value descriptor, ArrayRef<Value> indices,
+                             Value descriptor, ValueRange indices,
                              ArrayRef<int64_t> strides, int64_t offset,
                              ConversionPatternRewriter &rewriter) const;
 
   Value getDataPtr(Location loc, MemRefType type, Value memRefDesc,
-                   ArrayRef<Value> indices, ConversionPatternRewriter &rewriter,
+                   ValueRange indices, ConversionPatternRewriter &rewriter,
                    llvm::Module &module) const;
 
 protected:
   /// Reference to the type converter, with potential extensions.
   LLVMTypeConverter &typeConverter;
 };
 
 /// Utility class for operation conversions targeting the LLVM dialect that

mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h

 
 /// Performs the index computation to get to the element at `indices` of the
 /// memory pointed to by `basePtr`, using the layout map of `baseType`.
 
 // TODO(ravishankarm) : This method assumes that the `baseType` is a MemRefType
 // with AffineMap that has static strides. Extend to handle dynamic strides.
 spirv::AccessChainOp getElementPtr(SPIRVTypeConverter &typeConverter,
                                    MemRefType baseType, Value basePtr,
-                                   ArrayRef<Value> indices, Location loc,
+                                   ValueRange indices, Location loc,
                                    OpBuilder &builder);
 
 /// Sets the InterfaceVarABIAttr and EntryPointABIAttr for a function and its
 /// arguments.
 LogicalResult setABIAttrs(spirv::FuncOp funcOp,
                           EntryPointABIAttr entryPointInfo,
                           ArrayRef<InterfaceVarABIAttr> argABIInfo);
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_SPIRVLOWERING_H

mlir/include/mlir/TableGen/OpClass.h

enum Property {
     MP_None = 0x0,
     MP_Static = 0x1,      // Static method
     MP_Constructor = 0x2, // Constructor
     MP_Private = 0x4,     // Private method
   };
 
   OpMethod(StringRef retType, StringRef name, StringRef params,
            Property property, bool declOnly);
+  virtual ~OpMethod() = default;
 
   OpMethodBody &body();
 
   // Returns true if this is a static method.
   bool isStatic() const;
 
   // Returns true if this is a private method.
   bool isPrivate() const;
 
   // Writes the method as a declaration to the given `os`.
-  void writeDeclTo(raw_ostream &os) const;
+  virtual void writeDeclTo(raw_ostream &os) const;
   // Writes the method as a definition to the given `os`. `namePrefix` is the
   // prefix to be prepended to the method name (typically namespaces for
   // qualifying the method definition).
-  void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
+  virtual void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
 
-private:
+protected:
   Property properties;
   // Whether this method only contains a declaration.
   bool isDeclOnly;
   OpMethodSignature methodSignature;
   OpMethodBody methodBody;
 };
 
+// Class for holding an op's constructor method for C++ code emission.
+class OpConstructor : public OpMethod {
+public:
+  OpConstructor(StringRef retType, StringRef name, StringRef params,
+                Property property, bool declOnly)
+      : OpMethod(retType, name, params, property, declOnly){};
+
+  // Add member initializer to constructor initializing `name` with `value`.
+  void addMemberInitializer(StringRef name, StringRef value);
+
+  // Writes the method as a definition to the given `os`. `namePrefix` is the
+  // prefix to be prepended to the method name (typically namespaces for
+  // qualifying the method definition).
+  void writeDefTo(raw_ostream &os, StringRef namePrefix) const override;
+
+private:
+  // Member initializers.
+  std::string memberInitializers;
+};
+
 // A class used to emit C++ classes from Tablegen.  Contains a list of public
 // methods and a list of private fields to be emitted.
 class Class {
 public:
   explicit Class(StringRef name);
 
   // Creates a new method in this class.
   OpMethod &newMethod(StringRef retType, StringRef name, StringRef params = "",
                       OpMethod::Property = OpMethod::MP_None,
                       bool declOnly = false);
 
-  OpMethod &newConstructor(StringRef params = "", bool declOnly = false);
+  OpConstructor &newConstructor(StringRef params = "", bool declOnly = false);
 
   // Creates a new field in this class.
   void newField(StringRef type, StringRef name, StringRef defaultValue = "");
 
   // Writes this op's class as a declaration to the given `os`.
   void writeDeclTo(raw_ostream &os) const;
   // Writes the method definitions in this op's class to the given `os`.
   void writeDefTo(raw_ostream &os) const;
 
   // Returns the C++ class name of the op.
   StringRef getClassName() const { return className; }
 
 protected:
   std::string className;
+  SmallVector<OpConstructor, 2> constructors;
   SmallVector<OpMethod, 8> methods;
   SmallVector<std::string, 4> fields;
 };
 
 // Class for holding an op for C++ code emission
 class OpClass : public Class {
 public:
   explicit OpClass(StringRef name, StringRef extraClassDeclaration = "");

mlir/include/mlir/TableGen/Operator.h

public:
   std::string getOperationName() const;
 
   // Returns this op's C++ class name.
   StringRef getCppClassName() const;
 
   // Returns this op's C++ class name prefixed with namespaces.
   std::string getQualCppClassName() const;
 
+  // Returns the name of op's adaptor C++ class.
+  std::string getAdaptorName() const;
+
   /// A class used to represent the decorators of an operator variable, i.e.
   /// argument or result.
   struct VariableDecorator {
   public:
     explicit VariableDecorator(const llvm::Record *def) : def(def) {}
     const llvm::Record &getDef() const { return *def; }
 
   protected:

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

linearized = builder.create<LLVM::MulOp>(
         loc, this->getIndexType(), ArrayRef<Value>{linearized, allocSizes[i]});
     linearized = builder.create<LLVM::AddOp>(
         loc, this->getIndexType(), ArrayRef<Value>{linearized, indices[i]});
   }
   return linearized;
 }
 
 Value ConvertToLLVMPattern::getStridedElementPtr(
-    Location loc, Type elementTypePtr, Value descriptor,
-    ArrayRef<Value> indices, ArrayRef<int64_t> strides, int64_t offset,
+    Location loc, Type elementTypePtr, Value descriptor, ValueRange indices,
+    ArrayRef<int64_t> strides, int64_t offset,
     ConversionPatternRewriter &rewriter) const {
   MemRefDescriptor memRefDescriptor(descriptor);
 
   Value base = memRefDescriptor.alignedPtr(rewriter, loc);
   Value offsetValue = offset == MemRefType::getDynamicStrideOrOffset()
                           ? memRefDescriptor.offset(rewriter, loc)
                           : this->createIndexConstant(rewriter, loc, offset);
 
   for (int i = 0, e = indices.size(); i < e; ++i) {
     Value stride = strides[i] == MemRefType::getDynamicStrideOrOffset()
                        ? memRefDescriptor.stride(rewriter, loc, i)
                        : this->createIndexConstant(rewriter, loc, strides[i]);
     Value additionalOffset =
         rewriter.create<LLVM::MulOp>(loc, indices[i], stride);
     offsetValue =
         rewriter.create<LLVM::AddOp>(loc, offsetValue, additionalOffset);
   }
   return rewriter.create<LLVM::GEPOp>(loc, elementTypePtr, base, offsetValue);
 }
 
 Value ConvertToLLVMPattern::getDataPtr(Location loc, MemRefType type,
-                                       Value memRefDesc,
-                                       ArrayRef<Value> indices,
+                                       Value memRefDesc, ValueRange indices,
                                        ConversionPatternRewriter &rewriter,
                                        llvm::Module &module) const {
   LLVM::LLVMType ptrType = MemRefDescriptor(memRefDesc).getElementType();
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   auto successStrides = getStridesAndOffset(type, strides, offset);
   assert(succeeded(successStrides) && "unexpected non-strided memref");
   (void)successStrides;

 ///      and stride.
 /// The view op is replaced by the descriptor.
 struct ViewOpLowering : public ConvertOpToLLVMPattern<ViewOp> {
   using ConvertOpToLLVMPattern<ViewOp>::ConvertOpToLLVMPattern;
 
   // Build and return the value for the idx^th shape dimension, either by
   // returning the constant shape dimension or counting the proper dynamic size.
   Value getSize(ConversionPatternRewriter &rewriter, Location loc,
-                ArrayRef<int64_t> shape, ArrayRef<Value> dynamicSizes,
+                ArrayRef<int64_t> shape, ValueRange dynamicSizes,
                 unsigned idx) const {
     assert(idx < shape.size());
     if (!ShapedType::isDynamic(shape[idx]))
       return createIndexConstant(rewriter, loc, shape[idx]);
     // Count the number of dynamic dims in range [0, idx]
     unsigned nDynamic = llvm::count_if(shape.take_front(idx), [](int64_t v) {
       return ShapedType::isDynamic(v);
     });

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Index calculation
 //===----------------------------------------------------------------------===//
 
 spirv::AccessChainOp mlir::spirv::getElementPtr(
     SPIRVTypeConverter &typeConverter, MemRefType baseType, Value basePtr,
-    ArrayRef<Value> indices, Location loc, OpBuilder &builder) {
+    ValueRange indices, Location loc, OpBuilder &builder) {
   // Get base and offset of the MemRefType and verify they are static.
 
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(baseType, strides, offset)) ||
       llvm::is_contained(strides, MemRefType::getDynamicStrideOrOffset()) ||
       offset == MemRefType::getDynamicStrideOrOffset()) {
     return nullptr;
   }
 
   auto indexType = typeConverter.getIndexType(builder.getContext());
+
   SmallVector<Value, 2> linearizedIndices;
   // Add a '0' at the start to index into the struct.
   auto zero = spirv::ConstantOp::getZero(indexType, loc, builder);
   linearizedIndices.push_back(zero);
 
   if (baseType.getRank() == 0) {
     linearizedIndices.push_back(zero);
   } else {
     // TODO: Instead of this logic, use affine.apply and add patterns for
     // lowering affine.apply to standard ops. These will get lowered to SPIR-V
     // ops by the DialectConversion framework.
     Value ptrLoc = builder.create<spirv::ConstantOp>(
         loc, indexType, IntegerAttr::get(indexType, offset));
     assert(indices.size() == strides.size() &&
            "must provide indices for all dimensions");
-    for (auto index : enumerate(indices)) {
+    for (auto index : llvm::enumerate(indices)) {
       Value strideVal = builder.create<spirv::ConstantOp>(
           loc, indexType, IntegerAttr::get(indexType, strides[index.index()]));
       Value update =
           builder.create<spirv::IMulOp>(loc, strideVal, index.value());
       ptrLoc = builder.create<spirv::IAddOp>(loc, ptrLoc, update);
     }
     linearizedIndices.push_back(ptrLoc);
   }

mlir/lib/TableGen/OpClass.cpp

void tblgen::OpMethod::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
 
   methodSignature.writeDefTo(os, namePrefix);
   os << " {\n";
   methodBody.writeTo(os);
   os << "}";
 }
 
 //===----------------------------------------------------------------------===//
+// OpConstructor definitions
+//===----------------------------------------------------------------------===//
+
+void mlir::tblgen::OpConstructor::addMemberInitializer(StringRef name,
+                                                       StringRef value) {
+  memberInitializers.append(std::string(llvm::formatv(
+      "{0}{1}({2})", memberInitializers.empty() ? " : " : ", ", name, value)));
+}
+
+void mlir::tblgen::OpConstructor::writeDefTo(raw_ostream &os,
+                                             StringRef namePrefix) const {
+  if (isDeclOnly)
+    return;
+
+  methodSignature.writeDefTo(os, namePrefix);
+  os << " " << memberInitializers << " {\n";
+  methodBody.writeTo(os);
+  os << "}";
+}
+
+//===----------------------------------------------------------------------===//
 // Class definitions
 //===----------------------------------------------------------------------===//
 
 tblgen::Class::Class(StringRef name) : className(name) {}
 
 tblgen::OpMethod &tblgen::Class::newMethod(StringRef retType, StringRef name,
                                            StringRef params,
                                            OpMethod::Property property,
                                            bool declOnly) {
   methods.emplace_back(retType, name, params, property, declOnly);
   return methods.back();
 }
 
-tblgen::OpMethod &tblgen::Class::newConstructor(StringRef params,
+tblgen::OpConstructor &tblgen::Class::newConstructor(StringRef params,
                                                      bool declOnly) {
-  return newMethod("", getClassName(), params, OpMethod::MP_Constructor,
-                   declOnly);
+  constructors.emplace_back("", getClassName(), params,
+                            OpMethod::MP_Constructor, declOnly);
+  return constructors.back();
 }
 
 void tblgen::Class::newField(StringRef type, StringRef name,
                              StringRef defaultValue) {
   std::string varName = formatv("{0} {1}", type, name).str();
   std::string field = defaultValue.empty()
                           ? varName
                           : formatv("{0} = {1}", varName, defaultValue).str();
   fields.push_back(std::move(field));
 }
 
 void tblgen::Class::writeDeclTo(raw_ostream &os) const {
   bool hasPrivateMethod = false;
   os << "class " << className << " {\n";
   os << "public:\n";
-  for (const auto &method : methods) {
+  for (const auto &method :
+       llvm::concat<const OpMethod>(constructors, methods)) {
     if (!method.isPrivate()) {
       method.writeDeclTo(os);
       os << '\n';
     } else {
       hasPrivateMethod = true;
     }
   }
   os << '\n';
   os << "private:\n";
   if (hasPrivateMethod) {
-    for (const auto &method : methods) {
+    for (const auto &method :
+         llvm::concat<const OpMethod>(constructors, methods)) {
       if (method.isPrivate()) {
         method.writeDeclTo(os);
         os << '\n';
       }
     }
     os << '\n';
   }
   for (const auto &field : fields)
     os.indent(2) << field << ";\n";
   os << "};\n";
 }
 
 void tblgen::Class::writeDefTo(raw_ostream &os) const {
-  for (const auto &method : methods) {
+  for (const auto &method :
+       llvm::concat<const OpMethod>(constructors, methods)) {
     method.writeDefTo(os, className);
     os << "\n\n";
   }
 }
 
 //===----------------------------------------------------------------------===//
 // OpClass definitions
 //===----------------------------------------------------------------------===//

mlir/lib/TableGen/Operator.cpp

 std::string tblgen::Operator::getOperationName() const {
   auto prefix = dialect.getName();
   auto opName = def.getValueAsString("opName");
   if (prefix.empty())
     return std::string(opName);
   return std::string(llvm::formatv("{0}.{1}", prefix, opName));
 }
 
+std::string tblgen::Operator::getAdaptorName() const {
+  return std::string(llvm::formatv("{0}OperandAdaptor", getCppClassName()));
+}
+
 StringRef tblgen::Operator::getDialectName() const { return dialect.getName(); }
 
 StringRef tblgen::Operator::getCppClassName() const { return cppClassName; }
 
 std::string tblgen::Operator::getQualCppClassName() const {
   auto prefix = dialect.getCppNamespace();
   if (prefix.empty())
     return std::string(cppClassName);

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

let extraClassDeclaration = [{
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations
 
 // CHECK: class AOpOperandAdaptor {
 // CHECK: public:
-// CHECK:   AOpOperandAdaptor(ArrayRef<Value> values
-// CHECK:   ArrayRef<Value> getODSOperands(unsigned index);
+// CHECK:   AOpOperandAdaptor(ValueRange values
+// CHECK:   ValueRange getODSOperands(unsigned index);
 // CHECK:   Value a();
-// CHECK:   ArrayRef<Value> b();
+// CHECK:   ValueRange b();
 // CHECK:   IntegerAttr attr1();
 // CHECL:   FloatAttr attr2();
 // CHECK: private:
-// CHECK:   ArrayRef<Value> odsOperands;
+// CHECK:   ValueRange odsOperands;
 // CHECK: };
 
 // CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNRegions<1>::Impl, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
 // CHECK-NOT: OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using OperandAdaptor = AOpOperandAdaptor;
 // CHECK:   static StringRef getOperationName();
let arguments = (ins
     Variadic<I32>:$b,
     I32:$c,
     Variadic<I32>:$d,
     I32ElementsAttr:$operand_segment_sizes
   );
 }
 
 // CHECK-LABEL: AttrSizedOperandOpOperandAdaptor(
-// CHECK-SAME:    ArrayRef<Value> values
+// CHECK-SAME:    ValueRange values
 // CHECK-SAME:    DictionaryAttr attrs
-// CHECK:  ArrayRef<Value> a();
-// CHECK:  ArrayRef<Value> b();
+// CHECK:  ValueRange a();
+// CHECK:  ValueRange b();
 // CHECK:  Value c();
-// CHECK:  ArrayRef<Value> d();
+// CHECK:  ValueRange d();
 // CHECK:  DenseIntElementsAttr operand_segment_sizes();
 
 // Check op trait for different number of operands
 // ---
 
 def NS_BOp : NS_Op<"op_with_no_operand", []> {
   let arguments = (ins);
 }

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

 
 def OpA : NS_Op<"one_normal_operand_op", []> {
   let arguments = (ins I32:$input);
 }
 
 // CHECK-LABEL: OpA definitions
 
 // CHECK:      OpAOperandAdaptor::OpAOperandAdaptor
-// CHECK-NEXT: odsOperands = values
+// CHECK-SAME: odsOperands(values), odsAttrs(attrs)
 
 // CHECK:      void OpA::build
 // CHECK:        Value input
 // CHECK:        odsState.addOperands(input);
 
 // CHECK:      void OpA::build
 // CHECK:        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:         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: ArrayRef<Value> OpDOperandAdaptor::input1
+// CHECK-LABEL: ValueRange OpDOperandAdaptor::input1
 // CHECK-NEXT:    return getODSOperands(0);
 
 // CHECK-LABEL: Value OpDOperandAdaptor::input2
 // CHECK-NEXT:    return *getODSOperands(1).begin();
 
-// CHECK-LABEL: ArrayRef<Value> OpDOperandAdaptor::input3
+// CHECK-LABEL: ValueRange OpDOperandAdaptor::input3
 // CHECK-NEXT:    return getODSOperands(2);
 
 // CHECK-LABEL: Operation::operand_range OpD::input1
 // CHECK-NEXT: return getODSOperands(0);
 
 // CHECK-LABEL: Value OpD::input2
 // 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/OpDefinitionsGen.cpp

 class OpOperandAdaptorEmitter {
 public:
   static void emitDecl(const Operator &op, raw_ostream &os);
   static void emitDef(const Operator &op, raw_ostream &os);
 
 private:
   explicit OpOperandAdaptorEmitter(const Operator &op);
 
-  Class adapterClass;
+  Class adaptor;
 };
 } // end namespace
 
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
-    : adapterClass(op.getCppClassName().str() + "OperandAdaptor") {
-  adapterClass.newField("ArrayRef<Value>", "odsOperands");
-  adapterClass.newField("DictionaryAttr", "odsAttrs");
+    : adaptor(op.getAdaptorName()) {
+  adaptor.newField("ValueRange", "odsOperands");
+  adaptor.newField("DictionaryAttr", "odsAttrs");
   const auto *attrSizedOperands =
       op.getTrait("OpTrait::AttrSizedOperandSegments");
-  auto &constructor = adapterClass.newConstructor(
+  {
+    auto &constructor = adaptor.newConstructor(
         attrSizedOperands
-          ? "ArrayRef<Value> values, DictionaryAttr attrs"
-          : "ArrayRef<Value> values, DictionaryAttr attrs = nullptr");
-  constructor.body() << "  odsOperands = values;\n";
-  constructor.body() << "  odsAttrs = attrs;\n";
+            ? "ValueRange values, DictionaryAttr attrs"
+            : "ValueRange values, DictionaryAttr attrs = nullptr");
+    constructor.addMemberInitializer("odsOperands", "values");
+    constructor.addMemberInitializer("odsAttrs", "attrs");
+  }
+
+  {
+    auto &constructor = adaptor.newConstructor(
+        llvm::formatv("{0}& op", op.getCppClassName()).str());
+    constructor.addMemberInitializer("odsOperands",
+                                     "op.getOperation()->getOperands()");
+    constructor.addMemberInitializer("odsAttrs",
+                                     "op.getOperation()->getAttrDictionary()");
+  }
 
   std::string sizeAttrInit =
       formatv(adapterSegmentSizeAttrInitCode, "operand_segment_sizes");
-  generateNamedOperandGetters(op, adapterClass, sizeAttrInit,
-                              /*rangeType=*/"ArrayRef<Value>",
+  generateNamedOperandGetters(op, adaptor, sizeAttrInit,
+                              /*rangeType=*/"ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
   fctx.withBuilder("mlir::Builder(odsAttrs.getContext())");
 
   auto emitAttr = [&](StringRef name, Attribute attr) {
-    auto &body = adapterClass.newMethod(attr.getStorageType(), name).body();
+    auto &body = adaptor.newMethod(attr.getStorageType(), name).body();
     body << "  assert(odsAttrs && \"no attributes when constructing adapter\");"
          << "\n  " << attr.getStorageType() << " attr = "
          << "odsAttrs.get(\"" << name << "\").";
     if (attr.hasDefaultValue() || attr.isOptional())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();\n";
for (auto &namedAttr : op.getAttributes()) {
     const auto &name = namedAttr.name;
     const auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr())
       emitAttr(name, attr);
   }
 }
 
 void OpOperandAdaptorEmitter::emitDecl(const Operator &op, raw_ostream &os) {
-  OpOperandAdaptorEmitter(op).adapterClass.writeDeclTo(os);
+  OpOperandAdaptorEmitter(op).adaptor.writeDeclTo(os);
 }
 
 void OpOperandAdaptorEmitter::emitDef(const Operator &op, raw_ostream &os) {
-  OpOperandAdaptorEmitter(op).adapterClass.writeDefTo(os);
+  OpOperandAdaptorEmitter(op).adaptor.writeDefTo(os);
 }
 
 // Emits the opcode enum and op classes.
 static void emitOpClasses(const std::vector<Record *> &defs, raw_ostream &os,
                           bool emitDecl) {
   IfDefScope scope("GET_OP_CLASSES", os);
   // First emit forward declaration for each class, this allows them to refer
   // to each others in traits for example.