[mlir] Remove TypedAttr and ElementsAttr from DenseArrayAttr

[Mogball]

Summary

This patch removes the implementation of TypedAttr and ElementsAttr
from DenseArrayAttr and, in doing so, removes the need store a shaped
type. The attribute now stores a size (number of elements), an MLIR type
as a discriminator, and a raw byte array.

The intent of DenseArrayAttr was not to be a drop-in replacement for DenseElementsAttr. It was meant to be a simple container of integers or floats that map to C++ types. The ElementsAttr implementation on DenseArrayAttr had many holes in it, and fixing those holes would require evolving DenseArrayAttr in a way that is incompatible with its original purpose.

[rriddle]

I think some users are already relying on DenseArrayAttr implementing ElementsAttr. What's the plan for them? Would it be better to sever the dependency on ShapedType from ElementsAttr? That would still allow for the type simplifications on DenseArrayAttr.

[Mogball]

I would be very surprised if any user was finding the DenseArrayAttr ElementsAttr implementation useful, beyond storing an ElementsAttr and dyn_cast'ing to DenseElementsAttr, DenseResourceAttr, DenseArrayAttr, etc. My understanding is that most clients are using one of the base classes, which are not impacted by this change.

However, a follow up patch will introduce an ArrayElementsAttr that is backed by a DenseArrayAttr and provide the full ElementsAttr API

[rriddle]

In D137606#3916180, @Mogball wrote:

I would be very surprised if any user was finding the DenseArrayAttr ElementsAttr implementation useful, beyond storing an ElementsAttr and dyn_cast'ing to DenseElementsAttr, DenseResourceAttr, DenseArrayAttr, etc. My understanding is that most clients are using one of the base classes, which are not impacted by this change.

However, a follow up patch will introduce an ArrayElementsAttr that is backed by a DenseArrayAttr and provide the full ElementsAttr API

They are using ElementsAttr as the constraint on the op class, which would be broken directly by this change.

[mehdi_amini]

They are using ElementsAttr as the constraint on the op class, which would be broken directly by this change.

Mind elaborating on this? I don't quite get how we got a dependency on ElementsAttr so fast for DenseArrayAttr?

[rriddle]

In D137606#3916198, @mehdi_amini wrote:

They are using ElementsAttr as the constraint on the op class, which would be broken directly by this change.

Mind elaborating on this? I don't quite get how we got a dependency on ElementsAttr so fast for DenseArrayAttr?

E.g. https://github.com/tensorflow/tensorflow/blob/dba3770a39ef1d69c3b0156338e7cbe3902e4177/tensorflow/compiler/mlir/tosa/transforms/legalize_tf.cc#L804

(The op being created with that attribute expects an ElementsAttr)

Various other users have been switching over from DenseElementsAttr to DenseArrayAttr. Not saying the changes here aren't welcome, but we should have a pretty
clear path of the evolution going on to prevent back and forth churn for users. I would also hope for a small in between path for those that have already switched.

[mehdi_amini]

In D137606#3916241, @rriddle wrote:

In D137606#3916198, @mehdi_amini wrote:

They are using ElementsAttr as the constraint on the op class, which would be broken directly by this change.

Mind elaborating on this? I don't quite get how we got a dependency on ElementsAttr so fast for DenseArrayAttr?

E.g. https://github.com/tensorflow/tensorflow/blob/dba3770a39ef1d69c3b0156338e7cbe3902e4177/tensorflow/compiler/mlir/tosa/transforms/legalize_tf.cc#L804

Thanks!
(and... errrr.... UH!)

Various other users have been switching over from DenseElementsAttr to DenseArrayAttr. Not saying the changes here aren't welcome, but we should have a pretty
clear path of the evolution going on to prevent back and forth churn for users. I would also hope for a small in between path for those that have already switched.

Can they just go back to DenseElementsAttr? I'm not clear on the path forward right now but these usages don't seem desirable to me (ArrayElementsAttr seems speculative to me still).

[rriddle]

In D137606#3916263, @mehdi_amini wrote:

In D137606#3916241, @rriddle wrote:

In D137606#3916198, @mehdi_amini wrote:

They are using ElementsAttr as the constraint on the op class, which would be broken directly by this change.

Mind elaborating on this? I don't quite get how we got a dependency on ElementsAttr so fast for DenseArrayAttr?

E.g. https://github.com/tensorflow/tensorflow/blob/dba3770a39ef1d69c3b0156338e7cbe3902e4177/tensorflow/compiler/mlir/tosa/transforms/legalize_tf.cc#L804

Thanks!
(and... errrr.... UH!)

Various other users have been switching over from DenseElementsAttr to DenseArrayAttr. Not saying the changes here aren't welcome, but we should have a pretty
clear path of the evolution going on to prevent back and forth churn for users. I would also hope for a small in between path for those that have already switched.

Can they just go back to DenseElementsAttr? I'm not clear on the path forward right now but these usages don't seem desirable to me (ArrayElementsAttr seems speculative to me still).

Likely, in which case I'd be fine with this change (with the direction of what to do in the commit description). At this point we could likely just remove the auto-splatting from DenseElementsAttr, and direct users to prefer resources for "large" things.

[Mogball]

At this point we could likely just remove the auto-splatting from DenseElementsAttr, and direct users to prefer resources for "large" things.

DenseResourceAttr doesn't solve the problem of encoding repeated elements many times in the IR. We should split SplatElementsAttr out from DenseElementsAttr in that case, but the latter still has bit packing whereas DenseArrayAttr (and it's ElementsAttr derivative) does not

[rriddle]

In D137606#3916406, @Mogball wrote:

At this point we could likely just remove the auto-splatting from DenseElementsAttr, and direct users to prefer resources for "large" things.

DenseResourceAttr doesn't solve the problem of encoding repeated elements many times in the IR. We should split SplatElementsAttr out from DenseElementsAttr in that case, but the latter still has bit packing whereas DenseArrayAttr (and it's ElementsAttr derivative) does not

That's a semi orthogonal problem which has various potential solutions (we shouldn't be detecting huge splats at all at runtime, users should be responsible for knowing if they have a splat or not to some degree). I'd be fine with just removing all of the "undesirable" behavior of DenseElementsAttr -> remove bitpacking, split out splat, etc.

[rriddle]

Hitting approve because I forgot to, and my only real concern is about evolving DenseElementsAttr/communicating the intent with users.

[Mogball]

rebase

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

iterator(const GEPIndicesAdaptor *base,
              llvm::detail::IterOfRange<const DynamicRange> valuesIter)
         : base(base), rawConstantIter(rawConstantIter), valuesIter(valuesIter) {
     }
 
     value_type operator*() const {
       if (*rawConstantIter == GEPOp::kDynamicIndex)
         return *valuesIter;
 
-      return IntegerAttr::get(
-          ElementsAttr::getElementType(base->rawConstantIndices),
+      return IntegerAttr::get(base->rawConstantIndices.getElementType(),
                               *rawConstantIter);
     }
 
     iterator &operator++() {
       if (*rawConstantIter == GEPOp::kDynamicIndex)
         valuesIter++;
       rawConstantIter++;
       return *this;
     }

mlir/include/mlir/IR/BuiltinAttributes.td

if (!$_self.empty()) {
       auto *alloc = static_cast<char *>(
           $_allocator.allocate($_self.size(), alignof(uint64_t)));
       std::uninitialized_copy($_self.begin(), $_self.end(), alloc);
       $_dst = ArrayRef<char>(alloc, $_self.size());
     }
   }];
 }
 
-def Builtin_DenseArray : Builtin_Attr<
-    "DenseArray", [ElementsAttrInterface, TypedAttrInterface]> {
+def Builtin_DenseArray : Builtin_Attr<"DenseArray"> {
   let summary = "A dense array of integer or floating point elements.";
   let description = [{
     A dense array attribute is an attribute that represents a dense array of
     primitive element types. Contrary to DenseIntOrFPElementsAttr this is a
     flat unidimensional array which does not have a storage optimization for
     splat. This allows to expose the raw array through a C++ API as
     `ArrayRef<T>` for compatible types. The element type must be bool or an
     integer or float whose bitwidth is a multiple of 8. Bool elements are stored
let description = [{
     declarative assembly will omit the type and print directly:
 
     ```mlir
     [1, 2, 3]
     ```
   }];
 
   let parameters = (ins
-    AttributeSelfTypeParameter<"", "RankedTensorType">:$type,
+    "Type":$elementType,
+    "int64_t":$size,
     Builtin_DenseArrayRawDataParameter:$rawData
   );
 
   let builders = [
-    AttrBuilderWithInferredContext<(ins "RankedTensorType":$type,
+    AttrBuilderWithInferredContext<(ins "Type":$elementType, "unsigned":$size,
                                         "ArrayRef<char>":$rawData), [{
-      return $_get(type.getContext(), type, rawData);
+      return $_get(elementType.getContext(), elementType, size, rawData);
     }]>,
   ];
 
+  let genVerifyDecl = 1;
+
   let extraClassDeclaration = [{
-    /// Allow implicit conversion to ElementsAttr.
-    operator ElementsAttr() const {
-      return *this ? cast<ElementsAttr>() : nullptr;
-    }
-
-    /// ElementsAttr implementation.
-    using ContiguousIterableTypesT =
-        std::tuple<bool, int8_t, int16_t, int32_t, int64_t, float, double>;
-    FailureOr<const bool *>
-    try_value_begin_impl(OverloadToken<bool>) const;
-    FailureOr<const int8_t *>
-    try_value_begin_impl(OverloadToken<int8_t>) const;
-    FailureOr<const int16_t *>
-    try_value_begin_impl(OverloadToken<int16_t>) const;
-    FailureOr<const int32_t *>
-    try_value_begin_impl(OverloadToken<int32_t>) const;
-    FailureOr<const int64_t *>
-    try_value_begin_impl(OverloadToken<int64_t>) const;
-    FailureOr<const float *>
-    try_value_begin_impl(OverloadToken<float>) const;
-    FailureOr<const double *>
-    try_value_begin_impl(OverloadToken<double>) const;
+    /// Get the number of elements in the array.
+    int64_t size() const { return getSize(); }
+    /// Return true if there are no elements in the dense array.
+    bool empty() const { return !size(); }
   }];
-
-  let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DenseIntOrFPElementsAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_DenseIntOrFPElementsAttr : Builtin_Attr<
     "DenseIntOrFPElements", [ElementsAttrInterface, TypedAttrInterface],

mlir/lib/AsmParser/AttributeParser.cpp

public:
 
   /// Parse an integer element.
   ParseResult parseIntegerElement(Parser &p);
 
   /// Parse a floating point element.
   ParseResult parseFloatElement(Parser &p);
 
   /// Convert the current contents to a dense array.
-  DenseArrayAttr getAttr() {
-    return DenseArrayAttr::get(RankedTensorType::get(size, type), rawData);
-  }
+  DenseArrayAttr getAttr() { return DenseArrayAttr::get(type, size, rawData); }
 
 private:
   /// Append the raw data of an APInt to the result.
   void append(const APInt &data);
 
   /// The array element type.
   Type type;
   /// The resultant byte array representing the contents of the array.

 
 /// Parse a dense array attribute.
 Attribute Parser::parseDenseArrayAttr(Type attrType) {
   consumeToken(Token::kw_array);
   if (parseToken(Token::less, "expected '<' after 'array'"))
     return {};
 
   SMLoc typeLoc = getToken().getLoc();
-  Type eltType;
-  // If an attribute type was provided, use its element type.
-  if (attrType) {
-    auto tensorType = attrType.dyn_cast<RankedTensorType>();
-    if (!tensorType) {
-      emitError(typeLoc, "dense array attribute expected ranked tensor type");
-      return {};
-    }
-    eltType = tensorType.getElementType();
-
-    // Otherwise, parse a type.
-  } else if (!(eltType = parseType())) {
+  Type eltType = parseType();
+  if (!eltType) {
+    emitError(typeLoc, "expected an integer or floating point type");
     return {};
   }
 
   // Only bool or integer and floating point elements divisible by bytes are
   // supported.
   if (!eltType.isIntOrIndexOrFloat()) {
     emitError(typeLoc, "expected integer or float type, got: ") << eltType;
     return {};
   }
   if (!eltType.isInteger(1) && eltType.getIntOrFloatBitWidth() % 8 != 0) {
     emitError(typeLoc, "element type bitwidth must be a multiple of 8");
     return {};
   }
 
-  // If a type was provided, check that it matches the parsed type.
-  auto checkProvidedType = [&](DenseArrayAttr result) -> Attribute {
-    if (attrType && result.getType() != attrType) {
-      emitError(typeLoc, "expected attribute type ")
-          << attrType << " does not match parsed type " << result.getType();
-      return {};
-    }
-    return result;
-  };
-
   // Check for empty list.
-  if (consumeIf(Token::greater)) {
-    return checkProvidedType(
-        DenseArrayAttr::get(RankedTensorType::get(0, eltType), {}));
-  }
-  if (!attrType &&
-      parseToken(Token::colon, "expected ':' after dense array type"))
+  if (consumeIf(Token::greater))
+    return DenseArrayAttr::get(eltType, 0, {});
+
+  if (parseToken(Token::colon, "expected ':' after dense array type"))
     return {};
 
   DenseArrayElementParser eltParser(eltType);
   if (eltType.isIntOrIndex()) {
     if (parseCommaSeparatedList(
             [&] { return eltParser.parseIntegerElement(*this); }))
       return {};
   } else {
     if (parseCommaSeparatedList(
             [&] { return eltParser.parseFloatElement(*this); }))
       return {};
   }
   if (parseToken(Token::greater, "expected '>' to close an array attribute"))
     return {};
-  return checkProvidedType(eltParser.getAttr());
+  return eltParser.getAttr();
 }
 
 /// Parse a dense elements attribute.
 Attribute Parser::parseDenseElementsAttr(Type attrType) {
   auto attribLoc = getToken().getLoc();
   consumeToken(Token::kw_dense);
   if (parseToken(Token::less, "expected '<' after 'dense'"))
     return nullptr;

mlir/lib/IR/AsmPrinter.cpp

if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
         printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
       }
       os << '>';
     }
   } else if (auto stridedLayoutAttr = attr.dyn_cast<StridedLayoutAttr>()) {
     stridedLayoutAttr.print(os);
   } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayAttr>()) {
     os << "array<";
-    if (typeElision != AttrTypeElision::Must)
-      printType(denseArrayAttr.getType().getElementType());
+    printType(denseArrayAttr.getElementType());
     if (!denseArrayAttr.empty()) {
-      if (typeElision != AttrTypeElision::Must)
-        os << ": ";
       printDenseArrayAttr(denseArrayAttr);
     }
     os << ">";
     return;
   } else if (auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>()) {
     os << "dense_resource<";
     printResourceHandle(resourceAttr.getRawHandle());
     os << ">";

mlir/lib/IR/BuiltinAttributes.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // DenseArrayAttr
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 DenseArrayAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                       RankedTensorType type, ArrayRef<char> rawData) {
-  if (type.getRank() != 1)
-    return emitError() << "expected rank 1 tensor type";
-  if (!type.getElementType().isIntOrIndexOrFloat())
+                       Type elementType, int64_t size, ArrayRef<char> rawData) {
+  if (!elementType.isIntOrIndexOrFloat())
     return emitError() << "expected integer or floating point element type";
   int64_t dataSize = rawData.size();
-  int64_t size = type.getShape().front();
-  if (type.getElementType().isInteger(1)) {
-    if (size != dataSize)
-      return emitError() << "expected " << size
-                         << " bytes for i1 array but got " << dataSize;
-  } else if (size * type.getElementTypeBitWidth() != dataSize * 8) {
+  int64_t elementSize =
+      llvm::divideCeil(elementType.getIntOrFloatBitWidth(), CHAR_BIT);
+  if (size * elementSize != dataSize) {
     return emitError() << "expected data size (" << size << " elements, "
-                       << type.getElementTypeBitWidth()
-                       << " bits each) does not match: " << dataSize
+                       << elementSize
+                       << " bytes each) does not match: " << dataSize
                        << " bytes";
   }
   return success();
 }
 
-FailureOr<const bool *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<bool>) const {
-  if (auto attr = dyn_cast<DenseBoolArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const int8_t *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<int8_t>) const {
-  if (auto attr = dyn_cast<DenseI8ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const int16_t *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<int16_t>) const {
-  if (auto attr = dyn_cast<DenseI16ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const int32_t *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<int32_t>) const {
-  if (auto attr = dyn_cast<DenseI32ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const int64_t *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<int64_t>) const {
-  if (auto attr = dyn_cast<DenseI64ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const float *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<float>) const {
-  if (auto attr = dyn_cast<DenseF32ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-FailureOr<const double *>
-DenseArrayAttr::try_value_begin_impl(OverloadToken<double>) const {
-  if (auto attr = dyn_cast<DenseF64ArrayAttr>())
-    return attr.asArrayRef().begin();
-  return failure();
-}
-
 namespace {
 /// Instantiations of this class provide utilities for interacting with native
 /// data types in the context of DenseArrayAttr.
 template <size_t width,
           IntegerType::SignednessSemantics signedness = IntegerType::Signless>
 struct DenseArrayAttrIntUtil {
   static bool checkElementType(Type eltType) {
     auto type = eltType.dyn_cast<IntegerType>();
DenseArrayAttrImpl<T>::operator ArrayRef<T>() const {
   return ArrayRef<T>(reinterpret_cast<const T *>(raw.data()),
                      raw.size() / sizeof(T));
 }
 
 /// Builds a DenseArrayAttr<T> from an ArrayRef<T>.
 template <typename T>
 DenseArrayAttrImpl<T> DenseArrayAttrImpl<T>::get(MLIRContext *context,
                                                  ArrayRef<T> content) {
-  auto shapedType = RankedTensorType::get(
-      content.size(), DenseArrayAttrUtil<T>::getElementType(context));
+  Type elementType = DenseArrayAttrUtil<T>::getElementType(context);
   auto rawArray = ArrayRef<char>(reinterpret_cast<const char *>(content.data()),
                                  content.size() * sizeof(T));
-  return Base::get(context, shapedType, rawArray)
-      .template cast<DenseArrayAttrImpl<T>>();
+  return llvm::cast<DenseArrayAttrImpl<T>>(
+      Base::get(context, elementType, content.size(), rawArray));
 }
 
 template <typename T>
 bool DenseArrayAttrImpl<T>::classof(Attribute attr) {
   if (auto denseArray = attr.dyn_cast<DenseArrayAttr>())
     return DenseArrayAttrUtil<T>::checkElementType(denseArray.getElementType());
   return false;
 }

mlir/lib/IR/BuiltinDialectBytecode.cpp

void BuiltinDialectBytecodeInterface::write(
   writer.writeAttributes(attr.getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // DenseArrayAttr
 
 DenseArrayAttr BuiltinDialectBytecodeInterface::readDenseArrayAttr(
     DialectBytecodeReader &reader) const {
-  RankedTensorType type;
+  Type elementType;
+  uint64_t size;
   ArrayRef<char> blob;
-  if (failed(reader.readType(type)) || failed(reader.readBlob(blob)))
+  if (failed(reader.readType(elementType)) || failed(reader.readVarInt(size)) ||
+      failed(reader.readBlob(blob)))
     return DenseArrayAttr();
-  return DenseArrayAttr::get(type, blob);
+  return DenseArrayAttr::get(elementType, size, blob);
 }
 
 void BuiltinDialectBytecodeInterface::write(
     DenseArrayAttr attr, DialectBytecodeWriter &writer) const {
   writer.writeVarInt(builtin_encoding::kDenseArrayAttr);
-  writer.writeType(attr.getType());
+  writer.writeType(attr.getElementType());
+  writer.writeVarInt(attr.getSize());
   writer.writeOwnedBlob(attr.getRawData());
 }
 
 //===----------------------------------------------------------------------===//
 // DenseIntOrFPElementsAttr
 
 DenseElementsAttr BuiltinDialectBytecodeInterface::readDenseIntOrFPElementsAttr(
     DialectBytecodeReader &reader) const {

mlir/test/IR/attribute.mlir

"array.sizes"() {
     x2_si0 = array<si0: 0, 0>,
     x3_i24 = array<i24: -42, 42, 8388607>,
     x4_ui24 = array<ui24: 16777215>,
     x5_si24 = array<si24: -8388608>,
     x6_bf16 = array<bf16: 1.2, 3.4>,
     x7_f16 = array<f16: 1., 3.>
   }: () -> ()
 
-  // CHECK: test.typed_attr tensor<4xi32> = array<1, 2, 3, 4>
-  test.typed_attr tensor<4xi32> = array<1, 2, 3, 4>
   return
 }
 
 // -----
 
 func.func @testConfinedDenseArrayAttr() {
   "test.confined_dense_array_attr"() {
     i64attr = array<i64: 0, 2, 3>,

mlir/test/IR/elements-attr-interface.mlir

 
 // Check that we don't crash on empty element attributes.
 // expected-error@below {{Test iterating `int64_t`: }}
 // expected-error@below {{Test iterating `uint64_t`: }}
 // expected-error@below {{Test iterating `APInt`: }}
 // expected-error@below {{Test iterating `IntegerAttr`: }}
 arith.constant dense<> : tensor<0xi64>
 
-// expected-error@below {{Test iterating `bool`: true, false, true, false, true, false}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<i1: true, false, true, false, true, false>
-// expected-error@below {{Test iterating `int8_t`: 10, 11, -12, 13, 14}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<i8: 10, 11, -12, 13, 14>
-// expected-error@below {{Test iterating `int16_t`: 10, 11, -12, 13, 14}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<i16: 10, 11, -12, 13, 14>
-// expected-error@below {{Test iterating `int32_t`: 10, 11, -12, 13, 14}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<i32: 10, 11, -12, 13, 14>
-// expected-error@below {{Test iterating `int64_t`: 10, 11, -12, 13, 14}}
-arith.constant array<i64: 10, 11, -12, 13, 14>
-// expected-error@below {{Test iterating `float`: 10.00, 11.00, -12.00, 13.00, 14.00}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<f32: 10., 11., -12., 13., 14.>
-// expected-error@below {{Test iterating `double`: 10.00, 11.00, -12.00, 13.00, 14.00}}
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-arith.constant array<f64: 10., 11., -12., 13., 14.>
-
 // Check that we handle an external constant parsed from the config.
 // expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
 // expected-error@below {{Test iterating `uint64_t`: 1, 2, 3}}
 // expected-error@below {{Test iterating `APInt`: unable to iterate type}}
 // expected-error@below {{Test iterating `IntegerAttr`: unable to iterate type}}
 arith.constant #test.e1di64_elements<blob1> : tensor<3xi64>
 
 {-#
   dialect_resources: {
     test: {
       blob1: "0x08000000010000000000000002000000000000000300000000000000"
     }
   }
 #-}

mlir/test/IR/invalid-builtin-attributes.mlir

 
 // expected-error@below {{expected ':' after dense array type}}
 #attr = array<i8)
 
 // -----
 
 // expected-error@below {{expected '>' to close an array attribute}}
 #attr = array<i8: 1)
-
-// -----
-
-// expected-error@below {{dense array attribute expected ranked tensor type}}
-test.typed_attr i32 = array<1>
-
-// -----
-
-// expected-error@below {{does not match parsed type}}
-test.typed_attr tensor<1xi32> = array<>
-
-// -----
-
-// expected-error@below {{does not match parsed type}}
-test.typed_attr tensor<0xi32> = array<1>

mlir/test/lib/IR/TestBuiltinAttributeInterfaces.cpp

 using namespace test;
 
 // Helper to print one scalar value, force int8_t to print as integer instead of
 // char.
 template <typename T>
 static void printOneElement(InFlightDiagnostic &os, T value) {
   os << llvm::formatv("{0}", value).str();
 }
-template <>
-void printOneElement<int8_t>(InFlightDiagnostic &os, int8_t value) {
-  os << llvm::formatv("{0}", static_cast<int64_t>(value)).str();
-}
 
 namespace {
 struct TestElementsAttrInterface
     : public PassWrapper<TestElementsAttrInterface, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestElementsAttrInterface)
 
   StringRef getArgument() const final { return "test-elements-attr-interface"; }
   StringRef getDescription() const final {
     return "Test ElementsAttr interface support.";
   }
   void runOnOperation() override {
     getOperation().walk([&](Operation *op) {
       for (NamedAttribute attr : op->getAttrs()) {
         auto elementsAttr = attr.getValue().dyn_cast<ElementsAttr>();
         if (!elementsAttr)
           continue;
-        if (auto concreteAttr = attr.getValue().dyn_cast<DenseArrayAttr>()) {
-          llvm::TypeSwitch<DenseArrayAttr>(concreteAttr)
-              .Case([&](DenseBoolArrayAttr attr) {
-                testElementsAttrIteration<bool>(op, attr, "bool");
-              })
-              .Case([&](DenseI8ArrayAttr attr) {
-                testElementsAttrIteration<int8_t>(op, attr, "int8_t");
-              })
-              .Case([&](DenseI16ArrayAttr attr) {
-                testElementsAttrIteration<int16_t>(op, attr, "int16_t");
-              })
-              .Case([&](DenseI32ArrayAttr attr) {
-                testElementsAttrIteration<int32_t>(op, attr, "int32_t");
-              })
-              .Case([&](DenseI64ArrayAttr attr) {
-                testElementsAttrIteration<int64_t>(op, attr, "int64_t");
-              })
-              .Case([&](DenseF32ArrayAttr attr) {
-                testElementsAttrIteration<float>(op, attr, "float");
-              })
-              .Case([&](DenseF64ArrayAttr attr) {
-                testElementsAttrIteration<double>(op, attr, "double");
-              });
-          testElementsAttrIteration<int64_t>(op, elementsAttr, "int64_t");
-          continue;
-        }
         testElementsAttrIteration<int64_t>(op, elementsAttr, "int64_t");
         testElementsAttrIteration<uint64_t>(op, elementsAttr, "uint64_t");
         testElementsAttrIteration<APInt>(op, elementsAttr, "APInt");
         testElementsAttrIteration<IntegerAttr>(op, elementsAttr, "IntegerAttr");
       }
     });
   }