[mlir] Remove colon from empty dense array syntax

[Mogball]

Summary

E.g. array<i32:> -> array<i32>

[Mogball]

clang-format

[rriddle]

mlir/lib/AsmParser/AttributeParser.cpp

842

[jpienaar]

Nice, one description nit this is just removing it from empty arrays not in general

[lattner]

nice, thanks!

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     Syntax:
 
     ```
     dense-array-attribute ::= `[` `:` (integer-type | float-type) tensor-literal `]`
     ```
     Examples:
 
     ```mlir
-    array<i8:>
+    array<i8>
     array<i32: 10, 42>
     array<f64: 42., 12.>
     ```
 
     when a specific subclass is used as argument of an operation, the declarative
     assembly will omit the type and print directly:
     ```
     [1, 2, 3]

mlir/lib/AsmParser/AttributeParser.cpp

CustomAsmParser(Parser &parser)
       : AsmParserImpl<AsmParser>(parser.getToken().getLoc(), parser) {}
 };
 } // namespace
 
 /// Parse a dense array attribute.
 Attribute Parser::parseDenseArrayAttr(Type type) {
   consumeToken(Token::kw_array);
   SMLoc typeLoc = getToken().getLoc();
-  if (parseToken(Token::less, "expected '<' after 'array'"))
-    return {};
-  if (!type &&
-      (!(type = parseType()) ||
-       parseToken(Token::colon, "expected ':' after dense array type")))
+  if (parseToken(Token::less, "expected '<' after 'array'") ||
+      (!type && !(type = parseType())))
     return {};
   CustomAsmParser parser(*this);
   Attribute result;
   // Check for empty list.
   bool isEmptyList = getToken().is(Token::greater);
+  if (!isEmptyList &&
+      parseToken(Token::colon, "expected ':' after dense array type"))
+    return {};
 
   if (auto intType = type.dyn_cast<IntegerType>()) {
     switch (type.getIntOrFloatBitWidth()) {
     case 1:
       if (isEmptyList)
         result = DenseBoolArrayAttr::get(parser.getContext(), {});
       else
         result = DenseBoolArrayAttr::parseWithoutBraces(parser, Type{});

mlir/lib/IR/AsmPrinter.cpp

if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
         printDenseIntOrFPElementsAttr(indices, /*allowHex=*/false);
         os << ", ";
         printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
       }
       os << '>';
     }
   } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayBaseAttr>()) {
     typeElision = AttrTypeElision::Must;
-    os << "array<" << denseArrayAttr.getType().getElementType() << ":";
+    os << "array<" << denseArrayAttr.getType().getElementType();
     if (denseArrayAttr.size())
-      os << " ";
+      os << ": ";
     denseArrayAttr.printWithoutBraces(os);
     os << ">";
   } else if (auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>()) {
     os << "dense_resource<";
     printResourceHandle(resourceAttr.getRawHandle());
     os << ">";
   } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
     printLocation(locAttr);

mlir/test/IR/attribute.mlir

 // -----
 
 //===----------------------------------------------------------------------===//
 // Test DenseArrayAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @dense_array_attr
 func.func @dense_array_attr() attributes {
-// CHECK-SAME: emptyf32attr = array<f32:>,
-               emptyf32attr = array<f32:>,
-// CHECK-SAME: emptyf64attr = array<f64:>,
-               emptyf64attr = array<f64:>,
-// CHECK-SAME: emptyi16attr = array<i16:>,
-               emptyi16attr = array<i16:>,
-// CHECK-SAME: emptyi1attr = array<i1:>,
-               emptyi1attr = array<i1:>,
-// CHECK-SAME: emptyi32attr = array<i32:>,
-               emptyi32attr = array<i32:>,
-// CHECK-SAME: emptyi64attr = array<i64:>,
-               emptyi64attr = array<i64:>,
-// CHECK-SAME: emptyi8attr = array<i8:>,
-               emptyi8attr = array<i8:>,
+// CHECK-SAME: emptyf32attr = array<f32>,
+               emptyf32attr = array<f32>,
+// CHECK-SAME: emptyf64attr = array<f64>,
+               emptyf64attr = array<f64>,
+// CHECK-SAME: emptyi16attr = array<i16>,
+               emptyi16attr = array<i16>,
+// CHECK-SAME: emptyi1attr = array<i1>,
+               emptyi1attr = array<i1>,
+// CHECK-SAME: emptyi32attr = array<i32>,
+               emptyi32attr = array<i32>,
+// CHECK-SAME: emptyi64attr = array<i64>,
+               emptyi64attr = array<i64>,
+// CHECK-SAME: emptyi8attr = array<i8>,
+               emptyi8attr = array<i8>,
 // CHECK-SAME: f32attr = array<f32: 1.024000e+03, 4.530000e+02, -6.435000e+03>,
                f32attr = array<f32: 1024., 453., -6435.>,
 // CHECK-SAME: f64attr = array<f64: -1.420000e+02>,
                f64attr = array<f64: -142.>,
 // CHECK-SAME: i16attr = array<i16: 3, 5, -4, 10>,
                i16attr = array<i16: 3, 5, -4, 10>,
 // CHECK-SAME: i1attr = array<i1: true, false, true>,
                i1attr = array<i1: true, false, true>,