Update ODS variadic segments "magic" attributes to use native Properties

[mehdi_amini]

Summary

The operand_segment_sizes and result_segment_sizes Attributes are now inlined
in the operation as native propertie. We continue to support building an
Attribute on the fly for getAttr("operand_segment_sizes") and setting the
property from an attribute with setAttr("operand_segment_sizes", attr).

A new bytecode version is introduced to support backward compatibility and
backdeployments.

[ftynse]

Random question: how do you expect these to be set up from the C API? It feels like direct access would be preferable to constructing a magic-named attribute that is later decayed into a property.

[Mogball]

Been waiting for this one. @ftynse I think C bindings could just be added for direct access to the arrays.

[mehdi_amini]

Random question: how do you expect these to be set up from the C API? It feels like direct access would be preferable to constructing a magic-named attribute that is later decayed into a property.

I think your question applies generally to properties right? We should definitely take a closer look at how we want to plumb properties through the C API layer.
I'm struggling to see how to do something generic though: that is we can easily have per-op C building APIs, but a generic "createOperationByName" seems though?

[jpienaar]

mlir/include/mlir/Bytecode/BytecodeImplementation.h

85

expected

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

800

Why pass by reference?

mlir/lib/IR/ODSSupport.cpp

50

While here, "size" for consistency

mlir/test/IR/traits.mlir

386

Mmm, so we lose ability to differentiate between unset and "should be none"?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

163

Same as above

426

Does all of this need to be here?

447

Does this fix the number of segments more so than before? E.g., I think this could be changed after construction before.

[mehdi_amini]

Address comment and change the bytecode encoding for a sparse array

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

800

I should do a const ref and comment it out. But this is constructed before we start parsing the bytecode and populate later.

mlir/test/IR/traits.mlir

386

Yes: this is always the case with properties: they have a default ctor. Since this isn't a parsing check but a verifier check we only know there is an int32_t[4] array here and we can look its content but we don't know if it's default constructed or not.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

426

Yes: this really specifies the properties: it is an array of int32_t, with a specific size, and then all various way we will interact with the property.

447

You're correct that xxx_segment_sizes as an attribute could technically be changing its rank over time, but I'm not sure this matches any existing concept in ODS? Do you have something in mind?

[rriddle]

One of the easy wins of properties. I also vaguely recall we had some docs that referenced the segment attributes, do those need to be updated?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

174–176

Please drop the trivial braces

[mehdi_amini]

I grepped for segment in our doc and didn't find anything, except for VariadicOfVariadic which has a custom segment attribute. And that makes me think that I should likely handle VariadicOfVariadic as well!

[Mogball]

mlir/include/mlir/Bytecode/BytecodeImplementation.h

168

This is an interesting API. It reads and writes an array with a known max size. It may be worth mentioning that.

[mehdi_amini]

Document readSparseArray and remove trivial braces

[mehdi_amini]

Rename the property member odsOperandSegmentSizes for consistency with our coding style.
For backward compatibility, it is exported as an attribute with the old name.

[mehdi_amini]

Fixup

[mehdi_amini]

In D155919#4525632, @mehdi_amini wrote:

I grepped for segment in our doc and didn't find anything, except for VariadicOfVariadic which has a custom segment attribute. And that makes me think that I should likely handle VariadicOfVariadic as well!

Actually it is more involved here, I won't do it this time. Also it is runtime variable size I think, so it'd need to be a std::vector.

[gysit]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

447

@mehdi_amini we get the following compiler warning when using this downstream (upstream there seems to be no warnings for some reason):

.../llvm-project/install/include/mlir/Dialect/LLVMIR/LLVMOps.h.inc:10805:36: warning: comparison between two arrays is deprecated; to compare array addresses, use unary '+' to decay operands to pointers [-Wdeprecated-array-compare]
        rhs.odsOperandSegmentSizes == this->odsOperandSegmentSizes &&

It seems like there is a comparison between to int32_t c-arrays in the generated code that probably should compare the content of the arrays and not there addresses? Would it make sense to switch to std::array?

[mehdi_amini]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

447

Ah that's quite a bug!

I didn't think about std::array, but it will likely simplify a bunch of the code indeed (some calls to llvm::copy could be replaced by assignments I think) and make it safer. Feel free to send a patch, other I'll try to do it this week end.

mlir/include/mlir/Bytecode/BytecodeImplementation.h

 #define MLIR_BYTECODE_BYTECODEIMPLEMENTATION_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h"
 
 namespace mlir {
 //===----------------------------------------------------------------------===//
 // DialectBytecodeReader
 //===----------------------------------------------------------------------===//
 
 /// This class defines a virtual interface for reading a bytecode stream,
 /// providing hooks into the bytecode reader. As such, this class should only be
 /// derived and defined by the main bytecode reader, users (i.e. dialects)
 /// should generally only interact with this class via the
 /// BytecodeDialectInterface below.
 class DialectBytecodeReader {
 public:
   virtual ~DialectBytecodeReader() = default;
 
   /// Emit an error to the reader.
   virtual InFlightDiagnostic emitError(const Twine &msg = {}) = 0;
 
+  /// Return the bytecode version being read.
+  virtual uint64_t getBytecodeVersion() const = 0;
+
   /// Read out a list of elements, invoking the provided callback for each
   /// element. The callback function may be in any of the following forms:
   ///   * LogicalResult(T &)
   ///   * FailureOr<T>()
   template <typename T, typename CallbackFn>
   LogicalResult readList(SmallVectorImpl<T> &result, CallbackFn &&callback) {
     uint64_t size;
     if (failed(readVarInt(size)))
public:
   //===--------------------------------------------------------------------===//
 
   /// Read a reference to the given attribute.
   virtual LogicalResult readAttribute(Attribute &result) = 0;
   /// Read an optional reference to the given attribute. Returns success even if
   /// the Attribute isn't present.
   virtual LogicalResult readOptionalAttribute(Attribute &attr) = 0;
 
   template <typename T>
   LogicalResult readAttributes(SmallVectorImpl<T> &attrs) {
     return readList(attrs, [this](T &attr) { return readAttribute(attr); });
   }
   template <typename T>
   LogicalResult readAttribute(T &result) {
     Attribute baseResult;
     if (failed(readAttribute(baseResult)))
       return failure();
public:
 
   /// Read a signed variable width integer.
   virtual LogicalResult readSignedVarInt(int64_t &result) = 0;
   LogicalResult readSignedVarInts(SmallVectorImpl<int64_t> &result) {
     return readList(result,
                     [this](int64_t &value) { return readSignedVarInt(value); });
   }
 
+  /// Parse a variable length encoded integer whose low bit is used to encode an
+  /// unrelated flag, i.e: `(integerValue << 1) | (flag ? 1 : 0)`.
+  LogicalResult readVarIntWithFlag(uint64_t &result, bool &flag) {
+    if (failed(readVarInt(result)))
+      return failure();
+    flag = result & 1;
+    result >>= 1;
+    return success();
+  }
+
+  /// Read a "small" sparse array of integer <= 32 bits elements, where
+  /// index/value pairs can be compressed when the array is small.
+  /// Note that only some position of the array will be read and the ones
+  /// not stored in the bytecode are gonne be left untouched.
+  /// If the provided array is too small for the stored indices, an error
+  /// will be returned.
+  template <typename T>
+  LogicalResult readSparseArray(MutableArrayRef<T> array) {
+    static_assert(sizeof(T) < sizeof(uint64_t), "expect integer < 64 bits");
+    static_assert(std::is_integral<T>::value, "expects integer");
+    uint64_t nonZeroesCount;
+    bool useSparseEncoding;
+    if (failed(readVarIntWithFlag(nonZeroesCount, useSparseEncoding)))
+      return failure();
+    if (nonZeroesCount == 0)
+      return success();
+    if (!useSparseEncoding) {
+      // This is a simple dense array.
+      if (nonZeroesCount > array.size()) {
+        emitError("trying to read an array of ")
+            << nonZeroesCount << " but only " << array.size()
+            << " storage available.";
+        return failure();
+      }
+      for (int64_t index : llvm::seq<int64_t>(0, nonZeroesCount)) {
+        uint64_t value;
+        if (failed(readVarInt(value)))
+          return failure();
+        array[index] = value;
+      }
+      return success();
+    }
+    // Read sparse encoding
+    // This is the number of bits used for packing the index with the value.
+    uint64_t indexBitSize;
+    if (failed(readVarInt(indexBitSize)))
+      return failure();
+    constexpr uint64_t maxIndexBitSize = 8;
+    if (indexBitSize > maxIndexBitSize) {
+      emitError("reading sparse array with indexing above 8 bits: ")
+          << indexBitSize;
+      return failure();
+    }
+    for (uint32_t count : llvm::seq<uint32_t>(0, nonZeroesCount)) {
+      (void)count;
+      uint64_t indexValuePair;
+      if (failed(readVarInt(indexValuePair)))
+        return failure();
+      uint64_t index = indexValuePair & ~(uint64_t(-1) << (indexBitSize));
+      uint64_t value = indexValuePair >> indexBitSize;
+      if (index >= array.size()) {
+        emitError("reading a sparse array found index ")
+            << index << " but only " << array.size() << " storage available.";
+        return failure();
+      }
+      array[index] = value;
+    }
+    return success();
+  }
+
   /// Read an APInt that is known to have been encoded with the given width.
   virtual FailureOr<APInt> readAPIntWithKnownWidth(unsigned bitWidth) = 0;
 
   /// Read an APFloat that is known to have been encoded with the given
   /// semantics.
   virtual FailureOr<APFloat>
   readAPFloatWithKnownSemantics(const llvm::fltSemantics &semantics) = 0;
 
public:
 
   /// Write a signed variable width integer to the output stream. This should be
   /// the preferred method for emitting signed integers whenever possible.
   virtual void writeSignedVarInt(int64_t value) = 0;
   void writeSignedVarInts(ArrayRef<int64_t> value) {
     writeList(value, [this](int64_t value) { writeSignedVarInt(value); });
   }
 
+  /// Write a VarInt and a flag packed together.
+  void writeVarIntWithFlag(uint64_t value, bool flag) {
+    writeVarInt((value << 1) | (flag ? 1 : 0));
+  }
+
+  /// Write out a "small" sparse array of integer <= 32 bits elements, where
+  /// index/value pairs can be compressed when the array is small. This method
+  /// will scan the array multiple times and should not be used for large
+  /// arrays. The optional provided "zero" can be used to adjust for the
+  /// expected repeated value. We assume here that the array size fits in a 32
+  /// bits integer.
+  template <typename T>
+  void writeSparseArray(ArrayRef<T> array) {
+    static_assert(sizeof(T) < sizeof(uint64_t), "expect integer < 64 bits");
+    static_assert(std::is_integral<T>::value, "expects integer");
+    uint32_t size = array.size();
+    uint32_t nonZeroesCount = 0, lastIndex = 0;
+    for (uint32_t index : llvm::seq<uint32_t>(0, size)) {
+      if (!array[index])
+        continue;
+      nonZeroesCount++;
+      lastIndex = index;
+    }
+    // If the last position is too large, or the array isn't at least 50%
+    // sparse, emit it with a dense encoding.
+    if (lastIndex > 256 || nonZeroesCount > size / 2) {
+      // Emit the array size and a flag which indicates whether it is sparse.
+      writeVarIntWithFlag(size, false);
+      for (const T &elt : array)
+        writeVarInt(elt);
+      return;
+    }
+    // Emit sparse: first the number of elements we'll write and a flag
+    // indicating it is a sparse encoding.
+    writeVarIntWithFlag(nonZeroesCount, true);
+    if (nonZeroesCount == 0)
+      return;
+    // This is the number of bits used for packing the index with the value.
+    int indexBitSize = llvm::Log2_32_Ceil(lastIndex + 1);
+    writeVarInt(indexBitSize);
+    for (uint32_t index : llvm::seq<uint32_t>(0, lastIndex + 1)) {
+      T value = array[index];
+      if (!value)
+        continue;
+      uint64_t indexValuePair = (value << indexBitSize) | (index);
+      writeVarInt(indexValuePair);
+    }
+  }
+
   /// Write an APInt to the bytecode stream whose bitwidth will be known
   /// externally at read time. This method is useful for encoding APInt values
   /// when the width is known via external means, such as via a type. This
   /// method should generally only be invoked if you need an APInt, otherwise
   /// use the varint methods above. APInt values are generally encoded using
   /// zigzag encoding, to enable more efficient encodings for negative values.
   virtual void writeAPIntWithKnownWidth(const APInt &value) = 0;
 

mlir/include/mlir/Bytecode/Encoding.h

enum BytecodeVersion {
   /// Avoid recording unknown locations on block arguments (compression) started
   /// in version 4.
   kElideUnknownBlockArgLocation = 4,
 
   /// Support for encoding properties natively in bytecode instead of merged
   /// with the discardable attributes.
   kNativePropertiesEncoding = 5,
 
+  /// ODS emits operand/result segment_size as native properties instead of
+  /// an attribute.
+  kNativePropertiesODSSegmentSize = 6,
+
   /// The current bytecode version.
-  kVersion = 5,
+  kVersion = 6,
 
   /// An arbitrary value used to fill alignment padding.
   kAlignmentByte = 0xCB,
 };
 
 //===----------------------------------------------------------------------===//
 // Sections
 //===----------------------------------------------------------------------===//

mlir/include/mlir/IR/ODSSupport.h

 
 /// Convert a DenseI64ArrayAttr to the provided storage. It is expected that the
 /// storage has the same size as the array. An error is returned if the
 /// attribute isn't a DenseI64ArrayAttr or it does not have the same size. If
 /// the optional diagnostic is provided an error message is also emitted.
 LogicalResult convertFromAttribute(MutableArrayRef<int64_t> storage,
                                    Attribute attr, InFlightDiagnostic *diag);
 
+/// Convert a DenseI32ArrayAttr to the provided storage. It is expected that the
+/// storage has the same size as the array. An error is returned if the
+/// attribute isn't a DenseI32ArrayAttr or it does not have the same size. If
+/// the optional diagnostic is provided an error message is also emitted.
+LogicalResult convertFromAttribute(MutableArrayRef<int32_t> storage,
+                                   Attribute attr, InFlightDiagnostic *diag);
+
 /// Convert the provided ArrayRef<int64_t> to a DenseI64ArrayAttr attribute.
 Attribute convertToAttribute(MLIRContext *ctx, ArrayRef<int64_t> storage);
 
 } // namespace mlir
 
 #endif // MLIR_IR_ODSSUPPORT_H
 No newline at end of file

mlir/include/mlir/IR/OpBase.td

class IntProperty<string storageTypeParam = "", string desc = ""> :
   }];
 }
 
 class ArrayProperty<string storageTypeParam = "", int n, string desc = ""> :
   Property<storageTypeParam # "[" # n # "]", desc> {
   let interfaceType = "::llvm::ArrayRef<" # storageTypeParam # ">";
   let convertFromStorage = "$_storage";
   let assignToStorage = "::llvm::copy($_value, $_storage)";
+  let hashProperty = "llvm::hash_combine_range(std::begin($_storage), std::end($_storage));";
 }
 
 //===----------------------------------------------------------------------===//
 // Primitive attribute kinds
 
 // A generic attribute that must be constructed around a specific buildable type
 // `attrValType`. Backed by MLIR attribute kind `attrKind`.
 class TypedAttrBase<Type attrValType, string attrKind, Pred condition,

mlir/include/mlir/IR/OpDefinition.h

 // concrete ops (like DimOp) with very little boilerplate.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPDEFINITION_H
 #define MLIR_IR_OPDEFINITION_H
 
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/ODSSupport.h"
 #include "mlir/IR/Operation.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 #include <optional>
 #include <type_traits>
 
 namespace mlir {
 class Builder;

mlir/include/mlir/IR/OperationSupport.h

struct Model : public Impl {
 
     using Properties = std::remove_reference_t<
         decltype(std::declval<ConcreteOp>().getProperties())>;
 
     std::optional<Attribute> getInherentAttr(Operation *op,
                                              StringRef name) final {
       if constexpr (hasProperties) {
         auto concreteOp = cast<ConcreteOp>(op);
-        return ConcreteOp::getInherentAttr(concreteOp.getProperties(), name);
+        return ConcreteOp::getInherentAttr(concreteOp.getContext(),
+                                           concreteOp.getProperties(), name);
       }
       // If the op does not have support for properties, we dispatch back to the
       // dictionnary of discardable attributes for now.
       return cast<ConcreteOp>(op)->getDiscardableAttr(name);
     }
     void setInherentAttr(Operation *op, StringAttr name,
                          Attribute value) final {
       if constexpr (hasProperties) {
         auto concreteOp = cast<ConcreteOp>(op);
         return ConcreteOp::setInherentAttr(concreteOp.getProperties(), name,
                                            value);
       }
       // If the op does not have support for properties, we dispatch back to the
       // dictionnary of discardable attributes for now.
       return cast<ConcreteOp>(op)->setDiscardableAttr(name, value);
     }
     void populateInherentAttrs(Operation *op, NamedAttrList &attrs) final {
       if constexpr (hasProperties) {
         auto concreteOp = cast<ConcreteOp>(op);
-        ConcreteOp::populateInherentAttrs(concreteOp.getProperties(), attrs);
+        ConcreteOp::populateInherentAttrs(concreteOp.getContext(),
+                                          concreteOp.getProperties(), attrs);
       }
     }
     LogicalResult
     verifyInherentAttrs(OperationName opName, NamedAttrList &attributes,
                         function_ref<InFlightDiagnostic()> getDiag) final {
       if constexpr (hasProperties)
         return ConcreteOp::verifyInherentAttrs(opName, attributes, getDiag);
       return success();

mlir/include/mlir/TableGen/Property.h

 
 // Wrapper class providing helper methods for accessing MLIR Property defined
 // in TableGen. This class should closely reflect what is defined as class
 // `Property` in TableGen.
 class Property {
 public:
   explicit Property(const llvm::Record *record);
   explicit Property(const llvm::DefInit *init);
+  Property(StringRef storageType, StringRef interfaceType,
+           StringRef convertFromStorageCall, StringRef assignToStorageCall,
+           StringRef convertToAttributeCall, StringRef convertFromAttributeCall,
+           StringRef readFromMlirBytecodeCall,
+           StringRef writeToMlirBytecodeCall, StringRef hashPropertyCall,
+           StringRef defaultValue);
 
   // Returns the storage type.
-  StringRef getStorageType() const;
+  StringRef getStorageType() const { return storageType; }
 
   // Returns the interface type for this property.
-  StringRef getInterfaceType() const;
+  StringRef getInterfaceType() const { return interfaceType; }
 
   // Returns the template getter method call which reads this property's
   // storage and returns the value as of the desired return type.
-  StringRef getConvertFromStorageCall() const;
+  StringRef getConvertFromStorageCall() const { return convertFromStorageCall; }
 
   // Returns the template setter method call which reads this property's
   // in the provided interface type and assign it to the storage.
-  StringRef getAssignToStorageCall() const;
+  StringRef getAssignToStorageCall() const { return assignToStorageCall; }
 
   // Returns the conversion method call which reads this property's
   // in the storage type and builds an attribute.
-  StringRef getConvertToAttributeCall() const;
+  StringRef getConvertToAttributeCall() const { return convertToAttributeCall; }
 
   // Returns the setter method call which reads this property's
   // in the provided interface type and assign it to the storage.
-  StringRef getConvertFromAttributeCall() const;
+  StringRef getConvertFromAttributeCall() const {
+    return convertFromAttributeCall;
+  }
 
   // Returns the method call which reads this property from
   // bytecode and assign it to the storage.
-  StringRef getReadFromMlirBytecodeCall() const;
+  StringRef getReadFromMlirBytecodeCall() const {
+    return readFromMlirBytecodeCall;
+  }
 
   // Returns the method call which write this property's
   // to the the bytecode.
-  StringRef getWriteToMlirBytecodeCall() const;
+  StringRef getWriteToMlirBytecodeCall() const {
+    return writeToMlirBytecodeCall;
+  }
 
   // Returns the code to compute the hash for this property.
-  StringRef getHashPropertyCall() const;
+  StringRef getHashPropertyCall() const { return hashPropertyCall; }
 
   // Returns whether this Property has a default value.
-  bool hasDefaultValue() const;
+  bool hasDefaultValue() const { return !defaultValue.empty(); }
+
   // Returns the default value for this Property.
-  StringRef getDefaultValue() const;
+  StringRef getDefaultValue() const { return defaultValue; }
 
   // Returns the TableGen definition this Property was constructed from.
-  const llvm::Record &getDef() const;
+  const llvm::Record &getDef() const { return *def; }
 
 private:
   // The TableGen definition of this constraint.
   const llvm::Record *def;
+
+  // Elements describing a Property, in general fetched from the record.
+  StringRef storageType;
+  StringRef interfaceType;
+  StringRef convertFromStorageCall;
+  StringRef assignToStorageCall;
+  StringRef convertToAttributeCall;
+  StringRef convertFromAttributeCall;
+  StringRef readFromMlirBytecodeCall;
+  StringRef writeToMlirBytecodeCall;
+  StringRef hashPropertyCall;
+  StringRef defaultValue;
 };
 
 // A struct wrapping an op property and its name together
 struct NamedProperty {
   llvm::StringRef name;
   Property prop;
 };
 
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_PROPERTY_H_

mlir/lib/Bytecode/Reader/BytecodeReader.cpp

struct Entry {
     /// The raw data of this entry in the bytecode.
     ArrayRef<uint8_t> data;
   };
   using AttrEntry = Entry<Attribute>;
   using TypeEntry = Entry<Type>;
 
 public:
   AttrTypeReader(StringSectionReader &stringReader,
-                 ResourceSectionReader &resourceReader, Location fileLoc)
+                 ResourceSectionReader &resourceReader, Location fileLoc,
+                 uint64_t &bytecodeVersion)
       : stringReader(stringReader), resourceReader(resourceReader),
-        fileLoc(fileLoc) {}
+        fileLoc(fileLoc), bytecodeVersion(bytecodeVersion) {}
 
   /// Initialize the attribute and type information within the reader.
   LogicalResult initialize(MutableArrayRef<BytecodeDialect> dialects,
                            ArrayRef<uint8_t> sectionData,
                            ArrayRef<uint8_t> offsetSectionData);
 
   /// Resolve the attribute or type at the given index. Returns nullptr on
   /// failure.
private:
   ResourceSectionReader &resourceReader;
 
   /// The set of attribute and type entries.
   SmallVector<AttrEntry> attributes;
   SmallVector<TypeEntry> types;
 
   /// A location used for error emission.
   Location fileLoc;
+
+  /// Current bytecode version being used.
+  uint64_t &bytecodeVersion;
 };
 
 class DialectReader : public DialectBytecodeReader {
 public:
   DialectReader(AttrTypeReader &attrTypeReader,
                 StringSectionReader &stringReader,
-                ResourceSectionReader &resourceReader, EncodingReader &reader)
+                ResourceSectionReader &resourceReader, EncodingReader &reader,
+                uint64_t &bytecodeVersion)
       : attrTypeReader(attrTypeReader), stringReader(stringReader),
-        resourceReader(resourceReader), reader(reader) {}
+        resourceReader(resourceReader), reader(reader),
+        bytecodeVersion(bytecodeVersion) {}
 
   InFlightDiagnostic emitError(const Twine &msg) override {
     return reader.emitError(msg);
   }
 
+  uint64_t getBytecodeVersion() const override { return bytecodeVersion; }
+
   DialectReader withEncodingReader(EncodingReader &encReader) {
     return DialectReader(attrTypeReader, stringReader, resourceReader,
-                         encReader);
+                         encReader, bytecodeVersion);
   }
 
   Location getLoc() const { return reader.getLoc(); }
 
   //===--------------------------------------------------------------------===//
   // IR
   //===--------------------------------------------------------------------===//
 
LogicalResult readBool(bool &result) override {
     return reader.parseByte(result);
   }
 
 private:
   AttrTypeReader &attrTypeReader;
   StringSectionReader &stringReader;
   ResourceSectionReader &resourceReader;
   EncodingReader &reader;
+  uint64_t &bytecodeVersion;
 };
 
 /// Wraps the properties section and handles reading properties out of it.
 class PropertiesSectionReader {
 public:
   /// Initialize the properties section reader with the given section data.
   LogicalResult initialize(Location fileLoc, ArrayRef<uint8_t> sectionData) {
     if (sectionData.empty())
LogicalResult AttrTypeReader::parseAsmEntry(T &result, EncodingReader &reader,
   }
   return success();
 }
 
 template <typename T>
 LogicalResult AttrTypeReader::parseCustomEntry(Entry<T> &entry,
                                                EncodingReader &reader,
                                                StringRef entryType) {
-  DialectReader dialectReader(*this, stringReader, resourceReader, reader);
+  DialectReader dialectReader(*this, stringReader, resourceReader, reader,
+                              bytecodeVersion);
   if (failed(entry.dialect->load(dialectReader, fileLoc.getContext())))
     return failure();
   // Ensure that the dialect implements the bytecode interface.
   if (!entry.dialect->interface) {
     return reader.emitError("dialect '", entry.dialect->name,
                             "' does not implement the bytecode interface");
   }
 
class mlir::BytecodeReader::Impl {
   using LazyLoadableOpsMap =
       DenseMap<Operation *, LazyLoadableOpsInfo::iterator>;
 
 public:
   Impl(Location fileLoc, const ParserConfig &config, bool lazyLoading,
        llvm::MemoryBufferRef buffer,
        const std::shared_ptr<llvm::SourceMgr> &bufferOwnerRef)
       : config(config), fileLoc(fileLoc), lazyLoading(lazyLoading),
-        attrTypeReader(stringReader, resourceReader, fileLoc),
+        attrTypeReader(stringReader, resourceReader, fileLoc, version),
         // Use the builtin unrealized conversion cast operation to represent
         // forward references to values that aren't yet defined.
         forwardRefOpState(UnknownLoc::get(config.getContext()),
                           "builtin.unrealized_conversion_cast", ValueRange(),
                           NoneType::get(config.getContext())),
         buffer(buffer), bufferOwnerRef(bufferOwnerRef) {}
 
   /// Read the bytecode defined within `buffer` into the given block.
BytecodeReader::Impl::parseOpName(EncodingReader &reader,
   if (failed(parseEntry(reader, opNames, opName, "operation name")))
     return failure();
   wasRegistered = opName->wasRegistered;
   // Check to see if this operation name has already been resolved. If we
   // haven't, load the dialect and build the operation name.
   if (!opName->opName) {
     // Load the dialect and its version.
     DialectReader dialectReader(attrTypeReader, stringReader, resourceReader,
-                                reader);
+                                reader, version);
     if (failed(opName->dialect->load(dialectReader, getContext())))
       return failure();
     // If the opName is empty, this is because we use to accept names such as
     // `foo` without any `.` separator. We shouldn't tolerate this in textual
     // format anymore but for now we'll be backward compatible. This can only
     // happen with unregistered dialects.
     if (opName->name.empty()) {
       if (opName->dialect->getLoadedDialect())
LogicalResult BytecodeReader::Impl::parseResourceSection(
   }
 
   // If the resource sections are absent, there is nothing to do.
   if (!resourceData)
     return success();
 
   // Initialize the resource reader with the resource sections.
   DialectReader dialectReader(attrTypeReader, stringReader, resourceReader,
-                              reader);
+                              reader, version);
   return resourceReader.initialize(fileLoc, config, dialects, stringReader,
                                    *resourceData, *resourceOffsetData,
                                    dialectReader, bufferOwnerRef);
 }
 
 //===----------------------------------------------------------------------===//
 // UseListOrder Helpers
 
if (!wasRegistered)
                        "Unexpected missing `wasRegistered` opname flag at "
                        "bytecode version ")
              << version << " with properties.";
     // When an operation is emitted without being registered, the properties are
     // stored as an attribute. Otherwise the op must implement the bytecode
     // interface and control the serialization.
     if (wasRegistered) {
       DialectReader dialectReader(attrTypeReader, stringReader, resourceReader,
-                                  reader);
+                                  reader, version);
       if (failed(
               propertiesReader.read(fileLoc, dialectReader, &*opName, opState)))
         return failure();
     } else {
       // If the operation wasn't registered when it was emitted, the properties
       // was serialized as an attribute.
       if (failed(parseAttribute(reader, opState.propertiesAttr)))
         return failure();

mlir/lib/Bytecode/Writer/IRNumbering.h

public:
   }
 
   /// Return the number of operations in the given block.
   unsigned getOperationCount(Block *block) {
     assert(blockOperationCounts.count(block) && "block not numbered");
     return blockOperationCounts[block];
   }
 
+  /// Get the set desired bytecode version to emit.
+  int64_t getDesiredBytecodeVersion() const;
+
 private:
   /// This class is used to provide a fake dialect writer for numbering nested
   /// attributes and types.
   struct NumberingDialectWriter;
 
   /// Number the given IR unit for bytecode emission.
   void number(Attribute attr);
   void number(Block &block);

mlir/lib/Bytecode/Writer/IRNumbering.cpp

void writeOwnedString(StringRef) override {
     // TODO: It might be nice to prenumber strings and sort by the number of
     // references. This could potentially be useful for optimizing things like
     // file locations.
   }
   void writeOwnedBlob(ArrayRef<char> blob) override {}
   void writeOwnedBool(bool value) override {}
 
   int64_t getBytecodeVersion() const override {
-    llvm_unreachable("unexpected querying of version in IRNumbering");
+    return state.getDesiredBytecodeVersion();
   }
 
   /// The parent numbering state that is populated by this writer.
   IRNumberingState &state;
 };
 
 //===----------------------------------------------------------------------===//
 // IR Numbering
for (const auto &resource : resources) {
     auto *numbering =
         new (resourceAllocator.Allocate()) DialectResourceNumbering(
             dialectNumber.asmInterface->getResourceKey(resource));
     dialectNumber.resourceMap.insert({numbering->key, numbering});
     dialectResources.try_emplace(resource, numbering);
   }
 }
 
+int64_t IRNumberingState::getDesiredBytecodeVersion() const {
+  return config.getDesiredBytecodeVersion();
+}
+
 namespace {
 /// A dummy resource builder used to number dialect resources.
 struct NumberingResourceBuilder : public AsmResourceBuilder {
   NumberingResourceBuilder(DialectNumbering *dialect, unsigned &nextResourceID)
       : dialect(dialect), nextResourceID(nextResourceID) {}
   ~NumberingResourceBuilder() override = default;
 
   void buildBlob(StringRef key, ArrayRef<char>, uint32_t) final {

mlir/lib/IR/ODSSupport.cpp

if (!valueAttr) {
     return failure();
   }
   storage = valueAttr.getValue().getSExtValue();
   return success();
 }
 Attribute mlir::convertToAttribute(MLIRContext *ctx, int64_t storage) {
   return IntegerAttr::get(IntegerType::get(ctx, 64), storage);
 }
-LogicalResult mlir::convertFromAttribute(MutableArrayRef<int64_t> storage,
-                                         ::mlir::Attribute attr,
-                                         ::mlir::InFlightDiagnostic *diag) {
-  auto valueAttr = dyn_cast<DenseI64ArrayAttr>(attr);
+
+template <typename DenseArrayTy, typename T>
+LogicalResult convertDenseArrayFromAttr(MutableArrayRef<T> storage,
+                                        ::mlir::InFlightDiagnostic *diag,
+                                        StringRef denseArrayTyStr) {
+  auto valueAttr = dyn_cast<DenseArrayTy>(attr);
   if (!valueAttr) {
     if (diag)
-      *diag << "expected DenseI64ArrayAttr for key `value`";
+      *diag << "expected " << denseArrayTyStr << " for key `value`";
     return failure();
   }
   if (valueAttr.size() != static_cast<int64_t>(storage.size())) {
     if (diag)
-      *diag << "Size mismatch in attribute conversion: " << valueAttr.size()
+      *diag << "size mismatch in attribute conversion: " << valueAttr.size()
             << " vs " << storage.size();
     return failure();
   }
   llvm::copy(valueAttr.asArrayRef(), storage.begin());
   return success();
 }
+LogicalResult mlir::convertFromAttribute(MutableArrayRef<int64_t> storage,
+                                         ::mlir::Attribute attr,
+                                         ::mlir::InFlightDiagnostic *diag) {
+  return convertDenseArrayFromAttr<DenseI64ArrayAttr>(storage, attr, diag,
+                                                      "DenseI64ArrayAttr");
+}
+LogicalResult mlir::convertFromAttribute(MutableArrayRef<int32_t> storage,
+                                         Attribute attr,
+                                         InFlightDiagnostic *diag) {
+  return convertDenseArrayFromAttr<DenseI32ArrayAttr>(storage, attr, diag,
+                                                      "DenseI32ArrayAttr");
+}
+
 Attribute mlir::convertToAttribute(MLIRContext *ctx,
                                    ArrayRef<int64_t> storage) {
   return DenseI64ArrayAttr::get(ctx, storage);
 }

mlir/lib/TableGen/Property.cpp

 // Returns the initializer's value as string if the given TableGen initializer
 // is a code or string initializer. Returns the empty StringRef otherwise.
 static StringRef getValueAsString(const Init *init) {
   if (const auto *str = dyn_cast<StringInit>(init))
     return str->getValue().trim();
   return {};
 }
 
-Property::Property(const Record *record) : def(record) {
-  assert((record->isSubClassOf("Property") || record->isSubClassOf("Attr")) &&
+Property::Property(const Record *def)
+    : Property(getValueAsString(def->getValueInit("storageType")),
+               getValueAsString(def->getValueInit("interfaceType")),
+               getValueAsString(def->getValueInit("convertFromStorage")),
+               getValueAsString(def->getValueInit("assignToStorage")),
+               getValueAsString(def->getValueInit("convertToAttribute")),
+               getValueAsString(def->getValueInit("convertFromAttribute")),
+               getValueAsString(def->getValueInit("readFromMlirBytecode")),
+               getValueAsString(def->getValueInit("writeToMlirBytecode")),
+               getValueAsString(def->getValueInit("hashProperty")),
+               getValueAsString(def->getValueInit("defaultValue"))) {
+  this->def = def;
+  assert((def->isSubClassOf("Property") || def->isSubClassOf("Attr")) &&
          "must be subclass of TableGen 'Property' class");
 }
 
 Property::Property(const DefInit *init) : Property(init->getDef()) {}
 
-StringRef Property::getStorageType() const {
-  const auto *init = def->getValueInit("storageType");
-  auto type = getValueAsString(init);
-  if (type.empty())
-    return "Property";
-  return type;
+Property::Property(StringRef storageType, StringRef interfaceType,
+                   StringRef convertFromStorageCall,
+                   StringRef assignToStorageCall,
+                   StringRef convertToAttributeCall,
+                   StringRef convertFromAttributeCall,
+                   StringRef readFromMlirBytecodeCall,
+                   StringRef writeToMlirBytecodeCall,
+                   StringRef hashPropertyCall, StringRef defaultValue)
+    : storageType(storageType), interfaceType(interfaceType),
+      convertFromStorageCall(convertFromStorageCall),
+      assignToStorageCall(assignToStorageCall),
+      convertToAttributeCall(convertToAttributeCall),
+      convertFromAttributeCall(convertFromAttributeCall),
+      readFromMlirBytecodeCall(readFromMlirBytecodeCall),
+      writeToMlirBytecodeCall(writeToMlirBytecodeCall),
+      hashPropertyCall(hashPropertyCall), defaultValue(defaultValue) {
+  if (storageType.empty())
+    storageType = "Property";
 }
-
-StringRef Property::getInterfaceType() const {
-  const auto *init = def->getValueInit("interfaceType");
-  return getValueAsString(init);
-}
-
-StringRef Property::getConvertFromStorageCall() const {
-  const auto *init = def->getValueInit("convertFromStorage");
-  return getValueAsString(init);
-}
-
-StringRef Property::getAssignToStorageCall() const {
-  const auto *init = def->getValueInit("assignToStorage");
-  return getValueAsString(init);
-}
-
-StringRef Property::getConvertToAttributeCall() const {
-  const auto *init = def->getValueInit("convertToAttribute");
-  return getValueAsString(init);
-}
-
-StringRef Property::getConvertFromAttributeCall() const {
-  const auto *init = def->getValueInit("convertFromAttribute");
-  return getValueAsString(init);
-}
-
-StringRef Property::getReadFromMlirBytecodeCall() const {
-  const auto *init = def->getValueInit("readFromMlirBytecode");
-  return getValueAsString(init);
-}
-
-StringRef Property::getWriteToMlirBytecodeCall() const {
-  const auto *init = def->getValueInit("writeToMlirBytecode");
-  return getValueAsString(init);
-}
-
-StringRef Property::getHashPropertyCall() const {
-  return getValueAsString(def->getValueInit("hashProperty"));
-}
-
-bool Property::hasDefaultValue() const { return !getDefaultValue().empty(); }
-
-StringRef Property::getDefaultValue() const {
-  const auto *init = def->getValueInit("defaultValue");
-  return getValueAsString(init);
-}
-
-const llvm::Record &Property::getDef() const { return *def; }

mlir/test/IR/traits.mlir

^entry:
     "test.finish" () : () -> ()
   ^other:
     "test.finish" () : () -> ()
 }) : () -> ()
 
 // -----
 
 func.func @failedMissingOperandSizeAttr(%arg: i32) {
-  // expected-error @+1 {{requires dense i32 array attribute 'operand_segment_sizes'}}
+  // expected-error @+1 {{op operand count (4) does not match with the total size (0) specified in attribute 'operand_segment_sizes'}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @failedOperandSizeAttrWrongType(%arg: i32) {
-  // expected-error @+1 {{attribute 'operand_segment_sizes' failed to satisfy constraint: i32 dense array attribute}}
+  // expected-error @+1 {{op operand count (4) does not match with the total size (0) specified in attribute 'operand_segment_sizes'}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = 10} : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @failedOperandSizeAttrWrongElementType(%arg: i32) {
-  // expected-error @+1 {{attribute 'operand_segment_sizes' failed to satisfy constraint: i32 dense array attribute}}
+  // expected-error @+1 {{op operand count (4) does not match with the total size (0) specified in attribute 'operand_segment_sizes'}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = array<i64: 1, 1, 1, 1>} : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @failedOperandSizeAttrNegativeValue(%arg: i32) {
   // expected-error @+1 {{'operand_segment_sizes' attribute cannot have negative elements}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = array<i32: 1, 1, -1, 1>} : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @failedOperandSizeAttrWrongTotalSize(%arg: i32) {
   // expected-error @+1 {{operand count (4) does not match with the total size (3) specified in attribute 'operand_segment_sizes'}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = array<i32: 0, 1, 1, 1>} : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @failedOperandSizeAttrWrongCount(%arg: i32) {
-  // expected-error @+1 {{'operand_segment_sizes' attribute for specifying operand segments must have 4 elements}}
+  // expected-error @+1 {{test.attr_sized_operands' op operand count (4) does not match with the total size (0) specified in attribute 'operand_segment_sizes}}
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = array<i32: 2, 1, 1>} : (i32, i32, i32, i32) -> ()
 }
 
 // -----
 
 func.func @succeededOperandSizeAttr(%arg: i32) {
   // CHECK: test.attr_sized_operands
   "test.attr_sized_operands"(%arg, %arg, %arg, %arg) {operand_segment_sizes = array<i32: 0, 2, 1, 1>} : (i32, i32, i32, i32) -> ()
   return
 }
 
 // -----
 
 func.func @failedMissingResultSizeAttr() {
-  // expected-error @+1 {{requires dense i32 array attribute 'result_segment_sizes'}}
+  // expected-error @+1 {{op result count (4) does not match with the total size (0) specified in attribute 'result_segment_sizes'}}
   %0:4 = "test.attr_sized_results"() : () -> (i32, i32, i32, i32)
 }
 
 // -----
 
 func.func @failedResultSizeAttrWrongType() {
-  // expected-error @+1 {{requires dense i32 array attribute 'result_segment_sizes'}}
+  // expected-error @+1 {{ op result count (4) does not match with the total size (0) specified in attribute 'result_segment_sizes'}}
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = 10} : () -> (i32, i32, i32, i32)
 }
 
 
 // -----
 
 func.func @failedResultSizeAttrWrongElementType() {
-  // expected-error @+1 {{requires dense i32 array attribute 'result_segment_sizes'}}
+  // expected-error @+1 {{ op result count (4) does not match with the total size (0) specified in attribute 'result_segment_sizes'}}
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = array<i64: 1, 1, 1, 1>} : () -> (i32, i32, i32, i32)
 }
 
 // -----
 
 func.func @failedResultSizeAttrNegativeValue() {
   // expected-error @+1 {{'result_segment_sizes' attribute cannot have negative elements}}
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = array<i32: 1, 1, -1, 1>} : () -> (i32, i32, i32, i32)
 }
 
 // -----
 
 func.func @failedResultSizeAttrWrongTotalSize() {
   // expected-error @+1 {{result count (4) does not match with the total size (3) specified in attribute 'result_segment_sizes'}}
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = array<i32: 0, 1, 1, 1>} : () -> (i32, i32, i32, i32)
 }
 
 // -----
 
 func.func @failedResultSizeAttrWrongCount() {
-  // expected-error @+1 {{'result_segment_sizes' attribute for specifying result segments must have 4 elements, but got 3}}
+  // expected-error @+1 {{ op result count (4) does not match with the total size (0) specified in attribute 'result_segment_sizes'}}
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = array<i32: 2, 1, 1>} : () -> (i32, i32, i32, i32)
 }
 
 // -----
 
 func.func @succeededResultSizeAttr() {
   // CHECK: test.attr_sized_results
   %0:4 = "test.attr_sized_results"() {result_segment_sizes = array<i32: 0, 2, 1, 1>} : () -> (i32, i32, i32, i32)

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

 }
 
 def AttrSizedOperandOp : TEST_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,
     I32:$c,
-    Variadic<I32>:$d,
-    DenseI32ArrayAttr:$operand_segment_sizes
+    Variadic<I32>:$d
   );
 }
 
 def AttrSizedResultOp : TEST_Op<"attr_sized_results",
                                 [AttrSizedResultSegments]> {
   let results = (outs
     Variadic<I32>:$a,
     Variadic<I32>:$b,

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 )";
 /// The code snippet to initialize the sizes for the value range calculation.
 ///
 /// {0}: The code to get the attribute.
 static const char *const adapterSegmentSizeAttrInitCode = R"(
   assert({0} && "missing segment size attribute for op");
   auto sizeAttr = ::llvm::cast<::mlir::DenseI32ArrayAttr>({0});
 )";
+static const char *const adapterSegmentSizeAttrInitCodeProperties = R"(
+  ::llvm::ArrayRef<int32_t> sizeAttr = {0};
+)";
+
 /// The code snippet to initialize the sizes for the value range calculation.
 ///
 /// {0}: The code to get the attribute.
 static const char *const opSegmentSizeAttrInitCode = R"(
   auto sizeAttr = ::llvm::cast<::mlir::DenseI32ArrayAttr>({0});
 )";
 
 /// The logic to calculate the actual value range for a declared operand

 /// {0}: The begin iterator of the actual values.
 /// {1}: The call to generate the start and length of the value range.
 static const char *const valueRangeReturnCode = R"(
   auto valueRange = {1};
   return {{std::next({0}, valueRange.first),
            std::next({0}, valueRange.first + valueRange.second)};
 )";
 
+/// Read operand/result segment_size from bytecode.
+static const char *const readBytecodeSegmentSize = R"(
+if ($_reader.getBytecodeVersion() < /*kNativePropertiesODSSegmentSize=*/6) {
+  DenseI32ArrayAttr attr;
+  if (::mlir::failed($_reader.readAttribute(attr))) return failure();
+  if (attr.size() > static_cast<int64_t>(sizeof($_storage) / sizeof(int32_t))) {
+    $_reader.emitError("size mismatch for operand/result_segment_size");
+    return failure();
+  }
+  llvm::copy(ArrayRef<int32_t>(attr), $_storage);
+} else {
+  return $_reader.readSparseArray(MutableArrayRef($_storage));
+}
+)";
+
+/// Write operand/result segment_size to bytecode.
+static const char *const writeBytecodeSegmentSize = R"(
+if ($_writer.getBytecodeVersion() < /*kNativePropertiesODSSegmentSize=*/6)
+  $_writer.writeAttribute(DenseI32ArrayAttr::get(getContext(), $_storage));
+else
+  $_writer.writeSparseArray(ArrayRef($_storage));
+)";
+
 /// A header for indicating code sections.
 ///
 /// {0}: Some text, or a class name.
 /// {1}: Some text.
 static const char *const opCommentHeader = R"(
 //===----------------------------------------------------------------------===//
 // {0} {1}
 //===----------------------------------------------------------------------===//
public:
   }
 
   /// Returns whether to emit a `Properties` struct for this operation or not.
   bool hasProperties() const {
     if (!op.getProperties().empty())
       return true;
     if (!op.getDialect().usePropertiesForAttributes())
       return false;
+    if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments") ||
+        op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
+      return true;
     return llvm::any_of(getAttrMetadata(),
                         [](const std::pair<StringRef, AttributeMetadata> &it) {
                           return !it.second.constraint ||
                                  !it.second.constraint->isDerivedAttr();
                         });
   }
 
+  std::optional<NamedProperty> &getOperandSegmentsSize() {
+    return operandSegmentsSize;
+  }
+
+  std::optional<NamedProperty> &getResultSegmentsSize() {
+    return resultSegmentsSize;
+  }
+
 private:
   // Compute the attribute metadata.
   void computeAttrMetadata();
 
   // The operation ODS wrapper.
   const Operator &op;
   // True if code is being generate for an op. False for an adaptor.
   const bool emitForOp;
 
   // The attribute metadata, mapped by name.
   llvm::MapVector<StringRef, AttributeMetadata> attrMetadata;
+
+  // Property
+  std::optional<NamedProperty> operandSegmentsSize;
+  std::string operandSegmentsSizeStorage;
+  std::optional<NamedProperty> resultSegmentsSize;
+  std::string resultSegmentsSizeStorage;
+
   // The number of required attributes.
   unsigned numRequired;
 };
 
 } // namespace
 
 void OpOrAdaptorHelper::computeAttrMetadata() {
   // Enumerate the attribute names of this op, ensuring the attribute names are
   // unique in case implicit attributes are explicitly registered.
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     Attribute attr = namedAttr.attr;
     bool isOptional =
         attr.hasDefaultValue() || attr.isOptional() || attr.isDerivedAttr();
     attrMetadata.insert(
         {namedAttr.name, AttributeMetadata{namedAttr.name, !isOptional, attr}});
   }
+
+  auto makeProperty = [&](StringRef storageType) {
+    return Property(
+        /*storageType=*/storageType,
+        /*interfaceType=*/"::llvm::ArrayRef<int32_t>",
+        /*convertFromStorageCall=*/"$_storage",
+        /*assignToStorageCall=*/"::llvm::copy($_value, $_storage)",
+        /*convertToAttributeCall=*/
+        "DenseI32ArrayAttr::get($_ctxt, $_storage)",
+        /*convertFromAttributeCall=*/
+        "return convertFromAttribute($_storage, $_attr, $_diag);",
+        /*readFromMlirBytecodeCall=*/readBytecodeSegmentSize,
+        /*writeToMlirBytecodeCall=*/writeBytecodeSegmentSize,
+        /*hashPropertyCall=*/
+        "llvm::hash_combine_range(std::begin($_storage), "
+        "std::end($_storage));",
+        /*StringRef defaultValue=*/"");
+  };
   // Include key attributes from several traits as implicitly registered.
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
+    if (op.getDialect().usePropertiesForAttributes()) {
+      operandSegmentsSizeStorage =
+          llvm::formatv("int32_t[{0}]", op.getNumOperands());
+      operandSegmentsSize = {operandSegmentAttrName,
+                             makeProperty(operandSegmentsSizeStorage)};
+    } else {
       attrMetadata.insert(
-        {operandSegmentAttrName,
-         AttributeMetadata{operandSegmentAttrName, /*isRequired=*/true,
+          {operandSegmentAttrName, AttributeMetadata{operandSegmentAttrName,
+                                                     /*isRequired=*/true,
                                                      /*attr=*/std::nullopt}});
     }
+  }
   if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
+    if (op.getDialect().usePropertiesForAttributes()) {
+      resultSegmentsSizeStorage =
+          llvm::formatv("int32_t[{0}]", op.getNumResults());
+      resultSegmentsSize = {resultSegmentAttrName,
+                            makeProperty(resultSegmentsSizeStorage)};
+    } else {
       attrMetadata.insert(
           {resultSegmentAttrName,
            AttributeMetadata{resultSegmentAttrName, /*isRequired=*/true,
                              /*attr=*/std::nullopt}});
     }
+  }
 
   // Store the metadata in sorted order.
   SmallVector<AttributeMetadata> sortedAttrMetadata =
       llvm::to_vector(llvm::make_second_range(attrMetadata.takeVector()));
   llvm::sort(sortedAttrMetadata,
              [](const AttributeMetadata &lhs, const AttributeMetadata &rhs) {
                return lhs.attrName < rhs.attrName;
              });
if (numElements != {1})
       return {3}"'{0}' attribute for specifying {2} segments must have {1} "
                 "elements, but got ") << numElements;
   }
   )";
 
   // Verify a few traits first so that we can use getODSOperands() and
   // getODSResults() in the rest of the verifier.
   auto &op = emitHelper.getOp();
+  if (!op.getDialect().usePropertiesForAttributes()) {
     if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
       body << formatv(checkAttrSizedValueSegmentsCode, operandSegmentAttrName,
                       op.getNumOperands(), "operand",
                       emitHelper.emitErrorPrefix());
     }
     if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
       body << formatv(checkAttrSizedValueSegmentsCode, resultSegmentAttrName,
-                    op.getNumResults(), "result", emitHelper.emitErrorPrefix());
+                      op.getNumResults(), "result",
+                      emitHelper.emitErrorPrefix());
+    }
   }
 }
 
 // Return true if a verifier can be emitted for the attribute: it is not a
 // derived attribute, it has a predicate, its condition is not empty, and, for
 // adaptors, the condition does not reference the op.
 static bool canEmitAttrVerifier(Attribute attr, bool isEmittingForOp) {
   if (attr.isDerivedAttr())
PrintFatalError(op.getLoc(), "Unexpected overlap when generating `" +
                                    Twine(line) + ")");
 }
 
 #define ERROR_IF_PRUNED(M, N, O) errorIfPruned(__LINE__, M, N, O)
 
 void OpEmitter::genAttrNameGetters() {
   const llvm::MapVector<StringRef, AttributeMetadata> &attributes =
       emitHelper.getAttrMetadata();
-
+  bool hasOperandSegmentsSize =
+      op.getDialect().usePropertiesForAttributes() &&
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   // Emit the getAttributeNames method.
   {
     auto *method = opClass.addStaticInlineMethod(
         "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames");
     ERROR_IF_PRUNED(method, "getAttributeNames", op);
     auto &body = method->body();
-    if (attributes.empty()) {
+    if (!hasOperandSegmentsSize && attributes.empty()) {
       body << "  return {};";
       // Nothing else to do if there are no registered attributes. Exit early.
       return;
     }
     body << "  static ::llvm::StringRef attrNames[] = {";
     llvm::interleaveComma(llvm::make_first_range(attributes), body,
                           [&](StringRef attrName) {
                             body << "::llvm::StringRef(\"" << attrName << "\")";
                           });
+    if (hasOperandSegmentsSize) {
+      if (!attributes.empty())
+        body << ", ";
+      body << "::llvm::StringRef(\"" << operandSegmentAttrName << "\")";
+    }
     body << "};\n  return ::llvm::ArrayRef(attrNames);";
   }
 
   // Emit the getAttributeNameForIndex methods.
   {
     auto *method = opClass.addInlineMethod<Method::Private>(
         "::mlir::StringAttr", "getAttributeNameForIndex",
         MethodParameter("unsigned", "index"));
// 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(index));
     }
   }
+  if (hasOperandSegmentsSize) {
+    std::string name = op.getGetterName(operandSegmentAttrName);
+    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()
+          << " return (*this)->getName().getAttributeNames().back();";
+    }
+
+    // Generate the static variant.
+    {
+      auto *method = opClass.addStaticInlineMethod(
+          "::mlir::StringAttr", methodName,
+          MethodParameter("::mlir::OperationName", "name"));
+      ERROR_IF_PRUNED(method, methodName, op);
+      method->body() << " return name.getAttributeNames().back();";
+    }
+  }
 }
 
 // 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,
void OpEmitter::genPropertiesSupport() {
   SmallVector<ConstArgument> attrOrProperties;
   for (const std::pair<StringRef, AttributeMetadata> &it :
        emitHelper.getAttrMetadata()) {
     if (!it.second.constraint || !it.second.constraint->isDerivedAttr())
       attrOrProperties.push_back(&it.second);
   }
   for (const NamedProperty &prop : op.getProperties())
     attrOrProperties.push_back(&prop);
+  if (emitHelper.getOperandSegmentsSize())
+    attrOrProperties.push_back(&emitHelper.getOperandSegmentsSize().value());
+  if (emitHelper.getResultSegmentsSize())
+    attrOrProperties.push_back(&emitHelper.getResultSegmentsSize().value());
   if (attrOrProperties.empty())
     return;
   auto &setPropMethod =
       opClass
           .addStaticMethod(
               "::mlir::LogicalResult", "setPropertiesFromAttr",
               MethodParameter("Properties &", "prop"),
               MethodParameter("::mlir::Attribute", "attr"),
               MethodParameter("::mlir::InFlightDiagnostic *", "diag"))
           ->body();
   auto &getPropMethod =
       opClass
           .addStaticMethod("::mlir::Attribute", "getPropertiesAsAttr",
                            MethodParameter("::mlir::MLIRContext *", "ctx"),
                            MethodParameter("const Properties &", "prop"))
           ->body();
   auto &hashMethod =
       opClass
           .addStaticMethod("llvm::hash_code", "computePropertiesHash",
                            MethodParameter("const Properties &", "prop"))
           ->body();
   auto &getInherentAttrMethod =
       opClass
           .addStaticMethod("std::optional<mlir::Attribute>", "getInherentAttr",
+                           MethodParameter("::mlir::MLIRContext *", "ctx"),
                            MethodParameter("const Properties &", "prop"),
                            MethodParameter("llvm::StringRef", "name"))
           ->body();
   auto &setInherentAttrMethod =
       opClass
           .addStaticMethod("void", "setInherentAttr",
                            MethodParameter("Properties &", "prop"),
                            MethodParameter("llvm::StringRef", "name"),
                            MethodParameter("mlir::Attribute", "value"))
           ->body();
   auto &populateInherentAttrsMethod =
       opClass
           .addStaticMethod("void", "populateInherentAttrs",
+                           MethodParameter("::mlir::MLIRContext *", "ctx"),
                            MethodParameter("const Properties &", "prop"),
                            MethodParameter("::mlir::NamedAttrList &", "attrs"))
           ->body();
   auto &verifyInherentAttrsMethod =
       opClass
           .addStaticMethod(
               "::mlir::LogicalResult", "verifyInherentAttrs",
               MethodParameter("::mlir::OperationName", "opName"),
if (const auto *namedAttr =
             llvm::dyn_cast_if_present<const AttributeMetadata *>(attrOrProp)) {
       StringRef name = namedAttr->attrName;
       getInherentAttrMethod << formatv(getInherentAttrMethodFmt, name);
       setInherentAttrMethod << formatv(setInherentAttrMethodFmt, name);
       populateInherentAttrsMethod
           << formatv(populateInherentAttrsMethodFmt, name);
       continue;
     }
+    // The ODS segment size property is "special": we expose it as an attribute
+    // even though it is a native property.
+    const auto *namedProperty = cast<const NamedProperty *>(attrOrProp);
+    StringRef name = namedProperty->name;
+    if (name != operandSegmentAttrName && name != resultSegmentAttrName)
+      continue;
+    auto &prop = namedProperty->prop;
+    FmtContext fctx;
+    fctx.addSubst("_ctxt", "ctx");
+    fctx.addSubst("_storage", Twine("prop.") + name);
+    getInherentAttrMethod << formatv("    if (name == \"{0}\") return ", name);
+    getInherentAttrMethod << tgfmt(prop.getConvertToAttributeCall(), &fctx)
+                          << ";\n";
+
+    setInherentAttrMethod << formatv(R"decl(
+    if (name == "{0}") {{
+       auto arrAttr = dyn_cast_or_null<DenseI32ArrayAttr>(value);
+       if (!arrAttr) return;
+       if (arrAttr.size() != sizeof(prop.{0}) / sizeof(int32_t))
+         return;
+       llvm::copy(arrAttr.asArrayRef(), prop.{0});
+       return;
+    }
+)decl",
+                                     name);
+    populateInherentAttrsMethod
+        << formatv("  attrs.append(\"{0}\", {1});\n", name,
+                   tgfmt(prop.getConvertToAttributeCall(), &fctx));
   }
   getInherentAttrMethod << "  return std::nullopt;\n";
 
   // Emit the verifiers method for backward compatibility with the generic
   // syntax. This method verifies the constraint on the properties attributes
   // before they are set, since dyn_cast<> will silently omit failures.
   for (const auto &attrOrProp : attrOrProperties) {
     const auto *namedAttr = llvm::dyn_cast_if_present<const AttributeMetadata *>(attrOrProp);
generateNamedOperandGetters(const Operator &op, Class &opClass,
   }
 }
 
 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")) {
+    if (op.getDialect().usePropertiesForAttributes())
+      attrSizeInitCode =
+          formatv(adapterSegmentSizeAttrInitCodeProperties,
+                  llvm::formatv("getProperties().{0}", operandSegmentAttrName));
+
+    else
       attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
                                  emitHelper.getAttr(operandSegmentAttrName));
   }
 
   generateNamedOperandGetters(
       op, opClass,
       /*genericAdaptorBase=*/nullptr,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
       /*rangeElementType=*/"::mlir::Value",
for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
     body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"
          << "  auto mutableRange = "
             "::mlir::MutableOperandRange(getOperation(), "
             "range.first, range.second";
     if (attrSizedOperands) {
       if (emitHelper.hasProperties())
         body << formatv(
             ", ::mlir::MutableOperandRange::OperandSegment({0}u, "
-            "{getOperandSegmentSizesAttrName(), getProperties().{1}})",
+            "{getOperandSegmentSizesAttrName(), "
+            "DenseI32ArrayAttr::get(getContext(), getProperties().{1})})",
             i, operandSegmentAttrName);
       else
         body << formatv(
             ", ::mlir::MutableOperandRange::OperandSegment({0}u, *{1})", i,
             emitHelper.getAttr(operandSegmentAttrName, /*isNamed=*/true));
     }
     body << ");\n";
 
if (attrSizedResults && sameVariadicSize) {
     PrintFatalError(op.getLoc(),
                     "op cannot have both 'AttrSizedResultSegments' and "
                     "'SameVariadicResultSize' traits");
   }
 
   // Build the initializer string for the result segment size attribute.
   std::string attrSizeInitCode;
   if (attrSizedResults) {
+    if (op.getDialect().usePropertiesForAttributes())
+      attrSizeInitCode =
+          formatv(adapterSegmentSizeAttrInitCodeProperties,
+                  llvm::formatv("getProperties().{0}", resultSegmentAttrName));
+
+    else
       attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
                                  emitHelper.getAttr(resultSegmentAttrName));
   }
 
   generateValueRangeStartAndEnd(
       opClass, /*isGenericAdaptorBase=*/false, "getODSResultIndexAndLength",
       numVariadicResults, numNormalResults, "getOperation()->getNumResults()",
       attrSizedResults, attrSizeInitCode, op.getResults());
 
   auto *m =
case TypeParamKind::Separate:
         body << "  " << builderOpState << ".addTypes(" << resultNames[i]
              << ");\n";
       }
 
       // Automatically create the 'result_segment_sizes' attribute using
       // the length of the type ranges.
       if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
         if (op.getDialect().usePropertiesForAttributes()) {
-          body << "  (" << builderOpState
-               << ".getOrAddProperties<Properties>()." << resultSegmentAttrName
-               << " = \n"
-                  "        odsBuilder.getDenseI32ArrayAttr({";
+          body << "  llvm::copy(ArrayRef<int32_t>({";
         } else {
           std::string getterName = op.getGetterName(resultSegmentAttrName);
           body << " " << builderOpState << ".addAttribute(" << getterName
                << "AttrName(" << builderOpState << ".name), "
                << "odsBuilder.getDenseI32ArrayAttr({";
         }
         interleaveComma(
             llvm::seq<int>(0, op.getNumResults()), body, [&](int i) {
               const NamedTypeConstraint &result = op.getResult(i);
               if (!result.isVariableLength()) {
                 body << "1";
               } else if (result.isOptional()) {
                 body << "(" << resultNames[i] << " ? 1 : 0)";
               } else {
                 // VariadicOfVariadic of results are currently unsupported in
                 // MLIR, hence it can only be a simple variadic.
                 // TODO: Add implementation for VariadicOfVariadic results here
                 //       once supported.
                 assert(result.isVariadic());
                 body << "static_cast<int32_t>(" << resultNames[i] << ".size())";
               }
             });
+        if (op.getDialect().usePropertiesForAttributes()) {
+          body << "}), " << builderOpState
+               << ".getOrAddProperties<Properties>()." << resultSegmentAttrName
+               << ");\n";
+        } else {
           body << "}));\n";
         }
+      }
 
       return;
     case TypeParamKind::Collective: {
       int numResults = op.getNumResults();
       int numVariadicResults = op.getNumVariableLengthResults();
       int numNonVariadicResults = numResults - numVariadicResults;
       bool hasVariadicResult = numVariadicResults != 0;
 
for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     }
 
     if (operand.isOptional())
       body << "  if (" << argName << ")\n  ";
     body << "  " << builderOpState << ".addOperands(" << argName << ");\n";
   }
 
   // If the operation has the operand segment size attribute, add it here.
-  if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-    std::string sizes = op.getGetterName(operandSegmentAttrName);
-    if (op.getDialect().usePropertiesForAttributes()) {
-      body << "   (" << builderOpState << ".getOrAddProperties<Properties>()."
-           << operandSegmentAttrName << "= "
-           << "odsBuilder.getDenseI32ArrayAttr({";
-    } else {
-      body << "  " << builderOpState << ".addAttribute(" << sizes << "AttrName("
-           << builderOpState << ".name), "
-           << "odsBuilder.getDenseI32ArrayAttr({";
-    }
+  auto emitSegment = [&]() {
     interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
       const NamedTypeConstraint &operand = op.getOperand(i);
       if (!operand.isVariableLength()) {
         body << "1";
         return;
       }
 
       std::string operandName = getArgumentName(op, i);
       if (operand.isOptional()) {
         body << "(" << operandName << " ? 1 : 0)";
       } else if (operand.isVariadicOfVariadic()) {
         body << llvm::formatv(
             "static_cast<int32_t>(std::accumulate({0}.begin(), {0}.end(), 0, "
             "[](int32_t curSum, ::mlir::ValueRange range) {{ return curSum + "
             "range.size(); }))",
             operandName);
       } else {
         body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())";
       }
     });
+  };
+  if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
+    std::string sizes = op.getGetterName(operandSegmentAttrName);
+    if (op.getDialect().usePropertiesForAttributes()) {
+      body << "  llvm::copy(ArrayRef<int32_t>({";
+      emitSegment();
+      body << "}), " << builderOpState << ".getOrAddProperties<Properties>()."
+           << operandSegmentAttrName << ");\n";
+    } else {
+      body << "  " << builderOpState << ".addAttribute(" << sizes << "AttrName("
+           << builderOpState << ".name), "
+           << "odsBuilder.getDenseI32ArrayAttr({";
+      emitSegment();
       body << "}));\n";
     }
+  }
 
   // Push all attributes to the result.
   for (const auto &namedAttr : op.getAttributes()) {
     auto &attr = namedAttr.attr;
     if (attr.isDerivedAttr() || inferredAttributes.contains(namedAttr.name))
       continue;
 
     // TODO: The wrapping of optional is different for default or not, so don't
if (useProperties) {
     SmallVector<ConstArgument> attrOrProperties;
     for (const std::pair<StringRef, AttributeMetadata> &it :
          emitHelper.getAttrMetadata()) {
       if (!it.second.constraint || !it.second.constraint->isDerivedAttr())
         attrOrProperties.push_back(&it.second);
     }
     for (const NamedProperty &prop : op.getProperties())
       attrOrProperties.push_back(&prop);
+    if (emitHelper.getOperandSegmentsSize())
+      attrOrProperties.push_back(&emitHelper.getOperandSegmentsSize().value());
+    if (emitHelper.getResultSegmentsSize())
+      attrOrProperties.push_back(&emitHelper.getResultSegmentsSize().value());
     assert(!attrOrProperties.empty());
     std::string declarations = "  struct Properties {\n";
     llvm::raw_string_ostream os(declarations);
     std::string comparator =
         "    bool operator==(const Properties &rhs) const {\n"
         "      return \n";
     llvm::raw_string_ostream comparatorOs(comparator);
     for (const auto &attrOrProp : attrOrProperties) {
if (useProperties) {
           "(properties ? *properties.as<::mlir::EmptyProperties *>() : "
           "::mlir::EmptyProperties{}), "
           "regions");
     }
   }
 
   std::string sizeAttrInit;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
+    if (op.getDialect().usePropertiesForAttributes())
+      sizeAttrInit =
+          formatv(adapterSegmentSizeAttrInitCodeProperties,
+                  llvm::formatv("getProperties().{0}", operandSegmentAttrName));
+    else
       sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode,
                              emitHelper.getAttr(operandSegmentAttrName));
   }
   generateNamedOperandGetters(op, genericAdaptor,
                               /*genericAdaptorBase=*/&genericAdaptorBase,
                               /*sizeAttrInit=*/sizeAttrInit,
                               /*rangeType=*/"RangeT",
                               /*rangeElementType=*/"ValueT",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",

mlir/tools/mlir-tblgen/OpFormatGen.cpp

else
       body << "  result.addSuccessors(" << successor.name << "Successor);\n";
   }
 }
 
 void OperationFormat::genParserVariadicSegmentResolution(Operator &op,
                                                          MethodBody &body) {
   if (!allOperands) {
     if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-      if (op.getDialect().usePropertiesForAttributes()) {
-        body << formatv("  "
-                        "result.getOrAddProperties<{0}::Properties>().operand_"
-                        "segment_sizes = "
-                        "(parser.getBuilder().getDenseI32ArrayAttr({{",
-                        op.getCppClassName());
-      } else {
-        body << "  result.addAttribute(\"operand_segment_sizes\", "
-             << "parser.getBuilder().getDenseI32ArrayAttr({";
-      }
       auto interleaveFn = [&](const NamedTypeConstraint &operand) {
         // If the operand is variadic emit the parsed size.
         if (operand.isVariableLength())
           body << "static_cast<int32_t>(" << operand.name << "Operands.size())";
         else
           body << "1";
       };
+      if (op.getDialect().usePropertiesForAttributes()) {
+        body << "llvm::copy(ArrayRef<int32_t>({";
+        llvm::interleaveComma(op.getOperands(), body, interleaveFn);
+        body << formatv("}), "
+                        "result.getOrAddProperties<{0}::Properties>().operand_"
+                        "segment_sizes);\n",
+                        op.getCppClassName());
+      } else {
+        body << "  result.addAttribute(\"operand_segment_sizes\", "
+             << "parser.getBuilder().getDenseI32ArrayAttr({";
         llvm::interleaveComma(op.getOperands(), body, interleaveFn);
         body << "}));\n";
       }
+    }
     for (const NamedTypeConstraint &operand : op.getOperands()) {
       if (!operand.isVariadicOfVariadic())
         continue;
       if (op.getDialect().usePropertiesForAttributes()) {
         body << llvm::formatv(
             "  result.getOrAddProperties<{0}::Properties>().{1} = "
             "parser.getBuilder().getDenseI32ArrayAttr({2}OperandGroupSizes);\n",
             op.getCppClassName(),
             operand.constraint.getVariadicOfVariadicSegmentSizeAttr(),
             operand.name);
       } else {
         body << llvm::formatv(
             "  result.addAttribute(\"{0}\", "
             "parser.getBuilder().getDenseI32ArrayAttr({1}OperandGroupSizes));"
             "\n",
             operand.constraint.getVariadicOfVariadicSegmentSizeAttr(),
             operand.name);
       }
     }
   }
 
   if (!allResultTypes &&
       op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
-    if (op.getDialect().usePropertiesForAttributes()) {
-      body << formatv(
-          "  "
-          "result.getOrAddProperties<{0}::Properties>().result_segment_sizes = "
-          "(parser.getBuilder().getDenseI32ArrayAttr({{",
-          op.getCppClassName());
-    } else {
-      body << "  result.addAttribute(\"result_segment_sizes\", "
-           << "parser.getBuilder().getDenseI32ArrayAttr({";
-    }
     auto interleaveFn = [&](const NamedTypeConstraint &result) {
       // If the result is variadic emit the parsed size.
       if (result.isVariableLength())
         body << "static_cast<int32_t>(" << result.name << "Types.size())";
       else
         body << "1";
     };
+    if (op.getDialect().usePropertiesForAttributes()) {
+      body << "llvm::copy(ArrayRef<int32_t>({";
+      llvm::interleaveComma(op.getResults(), body, interleaveFn);
+      body << formatv(
+          "}), "
+          "result.getOrAddProperties<{0}::Properties>().result_segment_sizes"
+          ");\n",
+          op.getCppClassName());
+    } else {
+      body << "  result.addAttribute(\"result_segment_sizes\", "
+           << "parser.getBuilder().getDenseI32ArrayAttr({";
       llvm::interleaveComma(op.getResults(), body, interleaveFn);
       body << "}));\n";
     }
   }
+}
 
 //===----------------------------------------------------------------------===//
 // PrinterGen
 
 /// The code snippet used to generate a printer call for a region of an
 // operation that has the SingleBlockImplicitTerminator trait.
 ///
 /// {0}: The name of the region.

mlir/unittests/IR/AdaptorTest.cpp

TEST(Adaptor, GenericAdaptorsOperandAccess) {
   // Has optional arguments.
   OIListSimple::FoldAdaptor c({}, nullptr);
   {
     // Optional arguments return the default constructed value if not present.
     // Using optional instead of plain int here to differentiate absence of
     // value from the value 0.
     SmallVector<std::optional<int>> v = {0, 4};
     OIListSimple::Properties prop;
-    prop.operand_segment_sizes = builder.getDenseI32ArrayAttr({1, 0, 1});
+    llvm::copy(ArrayRef{1, 0, 1}, prop.operand_segment_sizes);
     OIListSimple::GenericAdaptor<ArrayRef<std::optional<int>>> d(v, {}, prop,
                                                                  {});
     EXPECT_EQ(d.getArg0(), 0);
     EXPECT_EQ(d.getArg1(), std::nullopt);
     EXPECT_EQ(d.getArg2(), 4);
   }
 
   // Has VariadicOfVariadic arguments.

mlir/unittests/IR/OpPropertiesTest.cpp

public:
   static StringRef getOperationName() {
     return "test_op_properties.op_with_properties";
   }
   // End boilerplate
 
   // This alias is the only definition needed for enabling "properties" for this
   // operation.
   using Properties = TestProperties;
-  static std::optional<mlir::Attribute> getInherentAttr(const Properties &prop,
+  static std::optional<mlir::Attribute> getInherentAttr(MLIRContext *context,
+                                                        const Properties &prop,
                                                         StringRef name) {
     return std::nullopt;
   }
   static void setInherentAttr(Properties &prop, StringRef name,
                               mlir::Attribute value) {}
-  static void populateInherentAttrs(const Properties &prop,
+  static void populateInherentAttrs(MLIRContext *context,
+                                    const Properties &prop,
                                     NamedAttrList &attrs) {}
   static LogicalResult
   verifyInherentAttrs(OperationName opName, NamedAttrList &attrs,
                       function_ref<InFlightDiagnostic()> getDiag) {
     return success();
   }
 };