[mlir][ods] Add ArrayOfAttr for creating custom array attributes

[Mogball]

Summary

ArrayOfAttr can be used to easily create an attribute that just
contains an array of something. The elements can be other attributes,
in which case the custom parsers and printers are invoked directly for
nice syntax, or any C++ type that supports parsing and printing, either
though custom printer and parser methods or FieldParser.

An array of integers:

def ArrayOfInts : ArrayOfAttr<Test_Dialect, "ArrayOfInts", "array_of_ints",
                              "int32_t">;

When embedded in an op's assembly format, it will look like

foo.ints value = [1, 2, 3]

An array of enums, when embedded in an op's assembly format, will look
like:

foo.enums value = [first, second, last]

[Mogball]

fix diff

[Mogball]

@mehdi_amini The generic syntax is "OK" (#foo<ints[1, 2, 3]>) but in theory you could instantiate this class multiple times to get bare integer arrays with no extra stuff

[mehdi_amini]

In D133131#3764610, @Mogball wrote:

@mehdi_amini The generic syntax is "OK" (#foo<ints[1, 2, 3]>) but in theory you could instantiate this class multiple times to get bare integer arrays with no extra stuff

I don't quite get what you mean?

[Mogball]

(Tangential to the overall patch, which is useful for many things esp enum array attrs). What I'm saying is that as long as you don't care about the generic syntax of the attribute very much, this is a viable alternative to the DenseArrayAttr subclasses.

mlir/include/mlir/IR/AttrTypeBase.td

class AttributeSelfTypeParameter<string desc,
                                  string derivedType = "::mlir::Type",
                                  string typeBuilder = ""> :
     AttrOrTypeParameter<derivedType, desc> {
   let defaultValue = !if(!and(!empty(typeBuilder),
                               !eq(derivedType, "::mlir::Type")),
                          "::mlir::NoneType::get($_ctxt)", typeBuilder);
 }
 
+//===----------------------------------------------------------------------===//
+// ArrayOfAttr
+//===----------------------------------------------------------------------===//
+
+/// This class defines an attribute that contains an array of elements. The
+/// elements can be any type, but if they are attributes, the nested elements
+/// are parsed and printed using the custom attribute syntax.
+class ArrayOfAttr<Dialect dialect, string attrName, string attrMnemonic,
+                  string eltName, list<Trait> traits = []>
+    : AttrDef<dialect, attrName, traits> {
+  let parameters = (ins ArrayRefParameter<eltName>:$value);
+  let mnemonic = attrMnemonic;
+  let assemblyFormat = "`[` $value `]`";
+
+  let returnType = "::llvm::ArrayRef<" # eltName # ">";
+  let constBuilderCall = "$_builder.getAttr<" # attrName # "Attr>($0)";
+  let convertFromStorage = "$_self.getValue()";
+
+  let extraClassDeclaration = [{
+    auto begin() const { return getValue().begin(); }
+    auto end() const { return getValue().end(); }
+    bool empty() const { return getValue().empty(); }
+    size_t size() const { return getValue().size(); }
+    auto &front() const { return getValue().front(); }
+    auto &back() const { return getValue().back(); }
+    auto &operator[](size_t index) { return getValue()[index]; }
+  }];
+}
+
 #endif // ATTRTYPEBASE_TD

mlir/test/IR/array-of-attr.mlir

+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+// CHECK: test.array_of_attr_op
+test.array_of_attr_op
+    // CHECK-SAME: a = [ begin 0 : index end, begin 2 : index end ]
+    a = [begin 0 : index end, begin 2 : index end],
+    // CHECK-SAME: [0, 1, -42, 42]
+    b = [0, 1, -42, 42],
+    // CHECK-SAME: [a, b, b, a]
+    c = [a, b, b, a]

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

 
 #ifndef TEST_ATTRDEFS
 #define TEST_ATTRDEFS
 
 // To get the test dialect definition.
 include "TestDialect.td"
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
+include "mlir/IR/EnumAttr.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SubElementInterfaces.td"
 
 // All of the attributes will extend this class.
 class Test_Attr<string name, list<Trait> traits = []>
     : AttrDef<Test_Dialect, name, traits>;
 
 def SimpleAttrA : Test_Attr<"SimpleA"> {
let extraClassDeclaration = [{
     mlir::FailureOr<const uint64_t *>
     try_value_begin_impl(OverloadToken<uint64_t>) const {
       return getElements().begin();
     }
   }];
   let assemblyFormat = "`<` $handle `>`";
 }
 
+// An array of nested attributes.
+def TestArrayOfUglyAttrs : ArrayOfAttr<Test_Dialect, "ArrayOfUglyAttrs",
+    "array_of_ugly", "TestAttrUglyAttr"> {
+  let assemblyFormat = "`[` $value ` ` `]`";
+}
+
+// An array of integers.
+def TestArrayOfInts : ArrayOfAttr<Test_Dialect, "ArrayOfInts",
+    "array_of_ints", "int32_t">;
+
+// An array of enum attributes.
+def TestSimpleEnum : I32EnumAttr<"SimpleEnum", "", [
+    I32EnumAttrCase<"a", 0>,
+    I32EnumAttrCase<"b", 1>
+  ]> {
+  let genSpecializedAttr = 0;
+  let cppNamespace = "::test";
+}
+def TestSimpleEnumAttr : EnumAttr<Test_Dialect, TestSimpleEnum, "simple_enum"> {
+  let assemblyFormat = "`` $value";
+}
+def TestArrayOfEnums : ArrayOfAttr<Test_Dialect, "ArrayOfEnums",
+    "array_of_enums", "SimpleEnumAttr">;
+
 #endif // TEST_ATTRDEFS

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

static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
       inferredReturnTypes.append(aTypes.begin(), aTypes.end());
       inferredReturnTypes.append(bTypes.begin(), bTypes.end());
       return ::mlir::success();
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// Test ArrayOfAttr
+//===----------------------------------------------------------------------===//
+
+// Embed the array attributes directly in the assembly format for a nice syntax.
+def ArrayOfAttrOp : TEST_Op<"array_of_attr_op"> {
+  let arguments = (ins TestArrayOfUglyAttrs:$a, TestArrayOfInts:$b,
+                       TestArrayOfEnums:$c);
+  let assemblyFormat = "`a` `=` $a `,` `b` `=` $b `,` `c` `=` $c attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
 // Test SideEffects
 //===----------------------------------------------------------------------===//
 
 def SideEffectOp : TEST_Op<"side_effect_op",
     [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      DeclareOpInterfaceMethods<TestEffectOpInterface>]> {
   let results = (outs AnyType:$result);
 }