[mlir] Store segment sizes in std::array

[gysit]

Summary

This revision uses std::array instead of normal c arrays to store the
operand and result segment sizes. This is a follow up to
https://reviews.llvm.org/D155919, which converted the operand and result
segment sizes to properties. Its use of c arrays triggered warnings in
downstream projects due to the direct comparison of c arrays. This
revision fixes the warnings using std::arrays that implement a
proper comparison operator, which compares the array elements rather
that the array pointers.

Note: it seems the comparison operator is effectively dead code for now.
It still seems useful to fix the warning and ensure the comparison works
as expected assume someone starts using it at some point in time.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 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);
+  llvm::copy(ArrayRef<int32_t>(attr), $_storage.begin());
 } else {
   return $_reader.readSparseArray(MutableArrayRef($_storage));
 }
 )";
 
 /// Write operand/result segment_size to bytecode.
 static const char *const writeBytecodeSegmentSize = R"(
 if ($_writer.getBytecodeVersion() < /*kNativePropertiesODSSegmentSize=*/6)
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)",
+        /*assignToStorageCall=*/
+        "llvm::copy($_value, $_storage.begin())",
         /*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());
+          llvm::formatv("std::array<int32_t, {0}>", op.getNumOperands());
       operandSegmentsSize = {"odsOperandSegmentSizes",
                              makeProperty(operandSegmentsSizeStorage)};
     } else {
       attrMetadata.insert(
           {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());
+          llvm::formatv("std::array<int32_t, {0}>", op.getNumResults());
       resultSegmentsSize = {"odsResultSegmentSizes",
                             makeProperty(resultSegmentsSizeStorage)};
     } else {
       attrMetadata.insert(
           {resultSegmentAttrName,
            AttributeMetadata{resultSegmentAttrName, /*isRequired=*/true,
                              /*attr=*/std::nullopt}});
     }
if (name == "odsOperandSegmentSizes") {
                      "\"{0}\") {{",
                      resultSegmentAttrName);
     }
     setInherentAttrMethod << formatv(R"decl(
        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});
+       llvm::copy(arrAttr.asArrayRef(), prop.{0}.begin());
        return;
     }
 )decl",
                                      name);
     if (name == "odsOperandSegmentSizes") {
       populateInherentAttrsMethod
           << formatv("  attrs.append(\"{0}\", {1});\n", operandSegmentAttrName,
                      tgfmt(prop.getConvertToAttributeCall(), &fctx));
case TypeParamKind::Separate:
                 // 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>().odsResultSegmentSizes);\n";
+               << ".getOrAddProperties<Properties>()."
+                  "odsResultSegmentSizes.begin());\n";
         } else {
           body << "}));\n";
         }
       }
 
       return;
     case TypeParamKind::Collective: {
       int numResults = op.getNumResults();
auto emitSegment = [&]() {
     });
   };
   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>().odsOperandSegmentSizes);\n";
+           << ".getOrAddProperties<Properties>()."
+              "odsOperandSegmentSizes.begin());\n";
     } else {
       body << "  " << builderOpState << ".addAttribute(" << sizes << "AttrName("
            << builderOpState << ".name), "
            << "odsBuilder.getDenseI32ArrayAttr({";
       emitSegment();
       body << "}));\n";
     }
   }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
         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>()."
-                        "odsOperandSegmentSizes);\n",
+                        "odsOperandSegmentSizes.begin());\n",
                         op.getCppClassName());
       } else {
         body << "  result.addAttribute(\"operand_segment_sizes\", "
              << "parser.getBuilder().getDenseI32ArrayAttr({";
         llvm::interleaveComma(op.getOperands(), body, interleaveFn);
         body << "}));\n";
       }
     }
auto interleaveFn = [&](const NamedTypeConstraint &result) {
       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>().odsResultSegmentSizes"
-          ");\n",
+      body << formatv("}), "
+                      "result.getOrAddProperties<{0}::Properties>()."
+                      "odsResultSegmentSizes.begin());\n",
                       op.getCppClassName());
     } else {
       body << "  result.addAttribute(\"result_segment_sizes\", "
            << "parser.getBuilder().getDenseI32ArrayAttr({";
       llvm::interleaveComma(op.getResults(), body, interleaveFn);
       body << "}));\n";
     }
   }
 }

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;
-    llvm::copy(ArrayRef{1, 0, 1}, prop.odsOperandSegmentSizes);
+    prop.odsOperandSegmentSizes = {1, 0, 1};
     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);
+
+    // Check the property comparison operator.
+    OIListSimple::Properties equivalentProp = {1, 0, 1};
+    OIListSimple::Properties differentProp = {0, 0, 1};
+    EXPECT_EQ(d.getProperties(), equivalentProp);
+    EXPECT_NE(d.getProperties(), differentProp);
   }
 
   // Has VariadicOfVariadic arguments.
   FormatVariadicOfVariadicOperand::FoldAdaptor e({});
   {
     SmallVector<int> v = {0, 1, 2, 3, 4};
     FormatVariadicOfVariadicOperand::Properties prop;
     prop.operand_segments = builder.getDenseI32ArrayAttr({3, 2, 0});