[mlir][ods] Allow empty array ref parameter

[Mogball]

Summary

This patch "fixes" a longstanding issue where the assembly format for
ArrayRefParameter could not handle an empty list. This is because there
was no way to generically optionally parse the first element of the
array. The only solution was to write a (relatively simple) custom parser.

This patch implements "empty" ArrayRefParameters by using
inverted optional groups and an optional ArrayRefParameter.

Depends on D133816

[rriddle]

mlir/include/mlir/IR/AttrTypeBase.td

420

This is kind of ugly. Have you considered an alternative where we allow parameters to implement a parseOptional method instead? That would let you keep the same syntax, and would compose much better.

[Mogball]

mlir/include/mlir/IR/AttrTypeBase.td

420

I actually think this is a much more elegant solution. Implementing an additional parseOptional on each parameter seems really onerous and it might not be possible in general.

For example, consider the array_of_ugly attribute in the test dialect:

foo = [ begin 4 end, begin 6 end ]

The attribute prefix can be stripped from the elements, but then what's the optional parser for ArrayRefParameter<"TestAttrUglyAttr">? You would need to be able to optionally parse an attribute with a stripped prefix.

Given assembly format the power to sidestep this issue entirely composes much better when the element types can be anything.

[Mogball]

mlir/include/mlir/IR/AttrTypeBase.td

420

You would need to be able to optionally parse an attribute with a stripped prefix.

Or hardcode parseOptionalKeyword("begin") just for that particular instantiation of ArrayRefParameter.

[rriddle]

mlir/include/mlir/IR/AttrTypeBase.td

365

typo: parameterse

[Mogball]

fix typo and rebase

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // attributes and types.
   string defaultValue = "";
 }
 class AttrParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 class TypeParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 
+// An optional parameter.
+class OptionalParameter<string type, string desc = ""> :
+    AttrOrTypeParameter<type, desc> {
+  let defaultValue = cppStorageType # "()";
+}
+
+// A parameter with a default value.
+class DefaultValuedParameter<string type, string value, string desc = ""> :
+    AttrOrTypeParameter<type, desc> {
+  let defaultValue = value;
+}
+
 // For StringRefs, which require allocation.
 class StringRefParameter<string desc = ""> :
     AttrOrTypeParameter<"::llvm::StringRef", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
   let printer = [{$_printer << '"' << $_self << '"';}];
   let cppStorageType = "std::string";
 }
 
 // For APFloats, which require comparison.
 class APFloatParameter<string desc> :
     AttrOrTypeParameter<"::llvm::APFloat", desc> {
   let comparator = "$_lhs.bitwiseIsEqual($_rhs)";
 }
 
 // For standard ArrayRefs, which require allocation.
 class ArrayRefParameter<string arrayOf, string desc = ""> :
     AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
   let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
 }
 
+// Regular array parameters cannot be parsed when empty. This optional array
+// parameter can be used with optional groups to be parsed when empty.
+class OptionalArrayRefParameter<string arrayOf, string desc = ""> :
+    OptionalParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
+  let allocator = [{$_dst = $_allocator.copyInto($_self);}];
+  let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
+  let comparator = "::llvm::makeArrayRef($_lhs) == ::llvm::makeArrayRef($_rhs)";
+}
+
 // For classes which require allocation and have their own allocateInto method.
 class SelfAllocationParameter<string type, string desc> :
     AttrOrTypeParameter<type, desc> {
   let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
 }
 
 // For ArrayRefs which contain things which allocate themselves.
 class ArrayRefOfSelfAllocationParameter<string arrayOf, string desc> :
     AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
   let allocator = [{
     llvm::SmallVector<}] # arrayOf # [{, 4> tmpFields;
     for (size_t i = 0, e = $_self.size(); i < e; ++i)
       tmpFields.push_back($_self[i].allocateInto($_allocator));
     $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
   }];
 }
 
-// An optional parameter.
-class OptionalParameter<string type, string desc = ""> :
-    AttrOrTypeParameter<type, desc> {
-  let defaultValue = cppStorageType # "()";
-}
-
-// A parameter with a default value.
-class DefaultValuedParameter<string type, string value, string desc = ""> :
-    AttrOrTypeParameter<type, desc> {
-  let defaultValue = value;
-}
-
 // This is a special attribute parameter that represents the "self" type of the
 // attribute. It is specially handled by the assembly format generator to derive
 // its value from the optional trailing type after each attribute.
 //
 // By default, the self type parameter is optional and has a default value of
 // `none`. If a derived type other than `::mlir::Type` is specified, the
 // parameter loses its default value unless another one is specified by
 // `typeBuilder`.

 //===----------------------------------------------------------------------===//
 
 /// 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 parameters = (ins OptionalArrayRefParameter<eltName>:$value);
   let mnemonic = attrMnemonic;
-  let assemblyFormat = "`[` $value `]`";
+  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(); }

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]
+
+// CHECK: test.array_of_attr_op
+// CHECK-SAME: a = [], b = [], c = []
+test.array_of_attr_op a = [], b = [], c = []

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

let extraClassDeclaration = [{
     }
   }];
   let assemblyFormat = "`<` $handle `>`";
 }
 
 // An array of nested attributes.
 def TestArrayOfUglyAttrs : ArrayOfAttr<Test_Dialect, "ArrayOfUglyAttrs",
     "array_of_ugly", "TestAttrUglyAttr"> {
-  let assemblyFormat = "`[` $value ` ` `]`";
+  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", "", [