[mlir] Surround array attributes with square brackets when parsing/printing.

[csigg]

Summary

Note: the type detection is different for the parser (has a push_back method) and printer (is an ArrayRef<T>).

Alternatively, one could override the parser/printer just for ArrayRefParameter. Please let me know if that's preferred.

[csigg]

Remove unused functions, fix test.

[Mogball]

I don't think this is something generically applicable. If you want a specific array parameter to be parsed with surrounding square brackets inside of struct(params), then I would recommend you just alter the parser and printer of that parameter instead of changing it for all array parameters:

def SquareBracketArrayParameter : AttrParameter<...> {
  let parser = "parseSquareBracketArray(...)";
  let printer = "printSquareBracketArray(...)";
}

mlir/docs/AttributesAndTypes.md

 };
 ```
 
 Example of using ODS parameter classes:
 
 ```tablegen
 def MyParameter : TypeParameter<"std::pair<int, int>", "pair of ints"> {
   let printer = [{ $_printer << $_self.first << " * " << $_self.second }];
-  let parser = [{ [&] -> FailureOr<std::pair<int, int>> {
+  let parser = [{ [&]() -> FailureOr<std::pair<int, int>> {
     int a, b;
     if ($_parser.parseInteger(a) || $_parser.parseStar() ||
         $_parser.parseInteger(b))
       return failure();
     return std::make_pair(a, b);
   }() }];
 }
 ```

mlir/include/mlir/IR/DialectImplementation.h

static FailureOr<ContainerT> parse(AsmParser &parser) {
     ContainerT elements;
     auto elementParser = [&]() {
       auto element = FieldParser<ElementT>::parse(parser);
       if (failed(element))
         return failure();
       elements.push_back(element.getValue());
       return success();
     };
-    if (parser.parseCommaSeparatedList(elementParser))
+    if (parser.parseCommaSeparatedList(AsmParser::Delimiter::Square,
+                                       elementParser))
       return failure();
     return elements;
   }
 };
 
 /// Parse an affine map.
 template <>
 struct FieldParser<AffineMap> {

mlir/include/mlir/IR/OpImplementation.h

public:
   /// method.
   template <typename AttrOrType,
             std::enable_if_t<!detect_has_print_method<AttrOrType>::value>
                 *sfinae = nullptr>
   void printStrippedAttrOrType(AttrOrType attrOrType) {
     *this << attrOrType;
   }
 
+  /// Overload for printing the provided array in the context of an operation
+  /// custom printer.
+  template <typename AttrOrType>
+  void printStrippedAttrOrType(ArrayRef<AttrOrType> attrsOrTypes) {
+    getStream() << '[';
+    *this << attrsOrTypes;
+    getStream() << ']';
+  }
+
   /// Print the given attribute without its type. The corresponding parser must
   /// provide a valid type for the attribute.
   virtual void printAttributeWithoutType(Attribute attr);
 
   /// Print the given string as a keyword, or a quoted and escaped string if it
   /// has any special or non-printable characters in it.
   virtual void printKeywordOrString(StringRef keyword);
 

mlir/include/mlir/Support/StorageUniquer.h

protected:
     BaseStorage() = default;
   };
 
   /// This is a utility allocator used to allocate memory for instances of
   /// derived types.
   class StorageAllocator {
   public:
     /// Copy the specified array of elements into memory managed by our bump
-    /// pointer allocator.  This assumes the elements are all PODs.
+    /// pointer allocator. T must be copy-constructible.
     template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
       if (elements.empty())
         return llvm::None;
       auto result = allocator.Allocate<T>(elements.size());
       std::uninitialized_copy(elements.begin(), elements.end(), result);
       return ArrayRef<T>(result, elements.size());
     }
 

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

def CompoundNestedOuterQual : Test_Attr<"CompoundNestedOuterQual"> {
   // List of type parameters.
   let parameters = (ins CompoundNestedInner:$inner);
   let assemblyFormat = "`<` `i`  qualified($inner) `>`";
 }
 
 def TestParamOne : AttrParameter<"int64_t", ""> {}
 
 def TestParamTwo : AttrParameter<"std::string", "", "llvm::StringRef"> {
+  let parser = [{ [&]() -> FailureOr<std::string> {
+    std::string str;
+    if (failed($_parser.parseString(&str)))
+      return failure();
+    return str;
+  }() }];
   let printer = "$_printer << '\"' << $_self << '\"'";
 }
 
-def TestParamFour : ArrayRefParameter<"int", ""> {
-  let cppStorageType = "llvm::SmallVector<int>";
-  let parser = "::parseIntArray($_parser)";
-  let printer = "::printIntArray($_printer, $_self)";
-}
+def TestParamFour : ArrayRefParameter<"int", "">;
 
 def TestAttrWithFormat : Test_Attr<"TestAttrWithFormat"> {
   let parameters = (
     ins
     TestParamOne:$one,
     TestParamTwo:$two,
     "::mlir::IntegerAttr":$three,
     TestParamFour:$four

mlir/test/lib/Dialect/Test/TestAttributes.cpp

 
 void CompoundAAttr::print(AsmPrinter &printer) const {
   printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
   llvm::interleaveComma(getArrayOfInts(), printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
-// CompoundAAttr
+// TestI64ElementsAttr
 //===----------------------------------------------------------------------===//
 
 Attribute TestI64ElementsAttr::parse(AsmParser &parser, Type type) {
   SmallVector<uint64_t> elements;
   if (parser.parseLess() || parser.parseLSquare())
     return Attribute();
   uint64_t intVal;
   while (succeeded(*parser.parseOptionalInteger(intVal))) {
TestAttrWithFormatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                int64_t one, std::string two, IntegerAttr three,
                                ArrayRef<int> four) {
   if (four.size() != static_cast<unsigned>(one))
     return emitError() << "expected 'one' to equal 'four.size()'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// Utility Functions for Generated Attributes
-//===----------------------------------------------------------------------===//
-
-static FailureOr<SmallVector<int>> parseIntArray(AsmParser &parser) {
-  SmallVector<int> ints;
-  if (parser.parseLSquare() || parser.parseCommaSeparatedList([&]() {
-        ints.push_back(0);
-        return parser.parseInteger(ints.back());
-      }) ||
-      parser.parseRSquare())
-    return failure();
-  return ints;
-}
-
-static void printIntArray(AsmPrinter &printer, ArrayRef<int> ints) {
-  printer << '[';
-  llvm::interleaveComma(ints, printer);
-  printer << ']';
-}
-
-//===----------------------------------------------------------------------===//
 // TestSubElementsAccessAttr
 //===----------------------------------------------------------------------===//
 
 Attribute TestSubElementsAccessAttr::parse(::mlir::AsmParser &parser,
                                            ::mlir::Type type) {
   Attribute first, second, third;
   if (parser.parseLess() || parser.parseAttribute(first) ||
       parser.parseComma() || parser.parseAttribute(second) ||

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

let parameters = (
     ins
     "uint32_t":$one,
     ArrayRefParameter<"int64_t">:$two,
     StringRefParameter<>:$three,
     "::test::CustomParam":$four
   );
 
   let mnemonic = "no_parser";
-  let assemblyFormat = "`<` $one `,` `[` $two `]` `,` $three `,` $four `>`";
+  let assemblyFormat = "`<` $one `,` $two `,` $three `,` $four `>`";
 }
 
 def TestTypeStructCaptureAll : Test_Type<"TestStructTypeCaptureAll"> {
   let parameters = (
     ins
     "int":$v0,
     "int":$v1,
     "int":$v2,