Updating test attribute and test to model list of integers

Author: quartersdg

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

@@ -81,11 +81,11 @@ def AttrWithTrait : Test_Attr<"AttrWithTrait", [TestAttrTrait]> {
   let mnemonic = "attr_with_trait";
 }
 
-// An attribute of decimal formatted integer.
-def TestDecimalIntegerAttr : Test_Attr<"TestDecimalInteger"> {
-  let mnemonic = "decimal_integer";
+// An attribute of a list of decimal formatted integers in similar format to shapes.
+def TestDecimalShapeAttr : Test_Attr<"TestDecimalShape"> {
+  let mnemonic = "decimal_shape";
 
-  let parameters = (ins "int64_t":$value);
+  let parameters = (ins ArrayRefParameter<"int64_t">:$shape);
 
   let hasCustomAssemblyFormat = 1;
 }

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

@@ -14,6 +14,7 @@
 #include "TestAttributes.h"
 #include "TestDialect.h"
 #include "TestTypes.h"
+#include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
@@ -66,22 +67,37 @@ void CompoundAAttr::print(AsmPrinter &printer) const {
 //===----------------------------------------------------------------------===//
 
 
-Attribute TestDecimalIntegerAttr::parse(AsmParser &parser, Type type) {
+Attribute TestDecimalShapeAttr::parse(AsmParser &parser, Type type) {
   if (parser.parseLess()){
     return Attribute();
   }
-  uint64_t intVal;
-  if (failed(*parser.parseOptionalDecimalInteger(intVal))) {
-    return Attribute();
-  }
-  if (parser.parseGreater()) {
-    return Attribute();
+  SmallVector<int64_t> shape;
+  if (parser.parseOptionalGreater()) {
+    auto parseDecimal = [&]() {
+      shape.emplace_back();
+      auto parseResult = parser.parseOptionalDecimalInteger(shape.back());
+      if (!parseResult.has_value() || failed(*parseResult)) {
+        parser.emitError(parser.getCurrentLocation()) << "expected an integer";
+        return failure();
+      }
+      return success();
+    };
+    if (failed(parseDecimal())) {
+      return Attribute();
+    }
+    while (failed(parser.parseOptionalGreater())) {
+      if (failed(parser.parseXInDimensionList()) || failed(parseDecimal())) {
+        return Attribute();
+      }
+    }
   }
-  return get(parser.getContext(), intVal);
+  return get(parser.getContext(), shape);
 }
 
-void TestDecimalIntegerAttr::print(AsmPrinter &printer) const {
-  printer << "<" << getValue() << ">";
+void TestDecimalShapeAttr::print(AsmPrinter &printer) const {
+  printer << "<";
+  llvm::interleave(getShape(), printer, "x");
+  printer << ">";
 }
 
 Attribute TestI64ElementsAttr::parse(AsmParser &parser, Type type) {

mlir/test/mlir-tblgen/testdialect-attrdefs.mlir

@@ -20,15 +20,27 @@ func.func private @overriddenAttr() attributes {
   foo = #test.override_builder<5>
 }
 
-// CHECK-LABEL: @decimalInteger
-// CHECK-SAME: foo = #test.decimal_integer<5>
-func.func private @decimalInteger() attributes {
-  foo = #test.decimal_integer<5>
+// CHECK-LABEL: @decimalIntegerShapeEmpty
+// CHECK-SAME: foo = #test.decimal_shape<>
+func.func private @decimalIntegerShapeEmpty() attributes {
+  foo = #test.decimal_shape<>
+}
+
+// CHECK-LABEL: @decimalIntegerShape
+// CHECK-SAME: foo = #test.decimal_shape<5>
+func.func private @decimalIntegerShape() attributes {
+  foo = #test.decimal_shape<5>
+}
+
+// CHECK-LABEL: @decimalIntegerShapeMultiple
+// CHECK-SAME: foo = #test.decimal_shape<0x3x7>
+func.func private @decimalIntegerShapeMultiple() attributes {
+  foo = #test.decimal_shape<0x3x7>
 }
 
 // -----
 
 func.func private @hexdecimalInteger() attributes {
-// expected-error @below {{expected '>'}}
-  foo = #test.decimal_integer<0x5>
+// expected-error @below {{expected an integer}}
+  sdg = #test.decimal_shape<1x0xb>
 }