Introduce a new Dense Array attribute

[mehdi_amini]

Summary

This attribute is similar to DenseElementsAttr but does not support
splat. As such it has a much simpler API and does not need any smart
iterator: it exposes direct ArrayRef access.

A new syntax is introduced so that the generic printing/parsing looks
like:

[:i64 1, -2, 3]

This attribute beings like an ArrayAttr but has a : token after the
opening square brace to introduce the element type (supported are I8,
I16, I32, I64, F32, F64) and the comma separated list for the data.

This is particularly convenient for attributes intended to be small,
like those referring to shapes.
For example a transpose operation with a dims attribute could be
defined as such:

let arguments = (ins AnyTensor:$input, DenseI64ArrayAttr:$dims);
let assemblyFormat = "$input `dims` `=` $dims attr-dict : type($input)";

And printed this way (the element type is elided in this case):

transpose %input dims = [0, 2, 1] : tensor<2x3x4xf32>

The C++ API for dims would just directly return an ArrayRef<int64>

RFC: https://discourse.llvm.org/t/rfc-introduce-a-new-dense-array-attribute/63279

[mehdi_amini]

Progres...

[mehdi_amini]

Completeness?

[mehdi_amini]

Rebase

[stephenneuendorffer]

mlir/include/mlir/IR/BuiltinAttributes.h

70

It seems very unfortunate not to be more generic. I assume the main reason is to provide native type iterators?

mlir/lib/IR/AsmPrinter.cpp

1882

"arrayref" seems misleading, since it's not really a ref... maybe just 'array'? 'densearray' might be more intuitive, but could be confused with the existing Attribute. Any other ideas?

[mehdi_amini]

mlir/include/mlir/IR/BuiltinAttributes.h

70

Yes, to be able to expose ArrayRef<T> we have to somehow hardcode the supported T...

mlir/lib/IR/AsmPrinter.cpp

1882

Right, I haven't been very inspired on this, I figured I'd get help through the review! :)

We already have ArrayAttr and DenseElementAtt which may lead to confusion...

[Mogball]

mlir/lib/IR/AsmPrinter.cpp

1882

List?

[stellaraccident]

mlir/lib/IR/AsmPrinter.cpp

1882

Just spit balling. In other settings, this would just be "array", "ndarray", "carry", etc.

In this context, it lives in a larger taxonomy where it is trying to convey a multidimensional container of dense pod primitive values that are byte aligned and match a c layout. (I'm not sure all of those restrictions are intentional, just calling out what it is now, I think)

I agree with Stephen, -1 on arrayref.

Maybe numeric_array? The existing ArrayAttr is really an AttributeArrayAttr.

[jpienaar]

mlir/lib/IR/AsmPrinter.cpp

1882

pod_array ?

prarray?

array<type> ? (array is nicer, there is no ref here, list makes me think the types could be different still)

We can also have keyword be separate from the backing type, e.g., a ArrayAttr of today could be considered an instance of this, so array Attribute [...] or array<Attribute> [...] or array [...] could be ArrayAttr while if one specified type it becomes this variant and so the keyword need not be confusing with it.

[mehdi_amini]

mlir/lib/IR/AsmPrinter.cpp

1882

I like the idea of unifying the array keyword with ArrayAtt actually.
This would be a breaking change but we can likely keep some backward compatibility in the parser for some time.

[mehdi_amini]

Change syntax to merge with array attribute

The new syntax is:

[:i8 1, 2, 3]

[mehdi_amini]

Jacques suggested offline a similar syntax that I adopted here, PTAL all!

[Mogball]

mlir/include/mlir/IR/BuiltinAttributes.h

74

Triple /// comments

76–78

87

Also triple comments ///

97

98

106–108

133

///

mlir/include/mlir/IR/OpBase.td

1267

Isn't this the default convertFromStorage?

mlir/lib/IR/AsmPrinter.cpp

1900

I wonder now whether we should do away with APint and APfloat for integer and float attrs with known widths...

mlir/lib/IR/AttributeDetail.h

74 ↗

(On Diff #438211)

Drop ::llvm::

mlir/lib/IR/BuiltinAttributes.cpp

788

parseCommaSeparatedList?

mlir/lib/Parser/AttributeParser.cpp

828

This seems a little unusual. Why is this necessary?

[mehdi_amini]

mlir/lib/Parser/AttributeParser.cpp

828

You need an instance of AsmParser to invoke a print() method on an attribute.

[jpienaar]

Nice, I like this notation: concise, backwards compatible, intuitive, no translation requires

mlir/include/mlir/IR/BuiltinAttributes.h

121

Missing update?

mlir/lib/Parser/AttributeParser.cpp

42

Can these be reverted now?

833

dense array attribute?

[stellaraccident]

Nice! Are the builtin dialect docs auto-generated somehow, or is there something we should update in this patch? (https://mlir.llvm.org/docs/Dialects/Builtin/#arrayattr)

[mehdi_amini]

mlir/include/mlir/IR/BuiltinAttributes.h

70

(let me know if you think of anything to do different here)

98

What's the diff here?

121

"type prefix" instead?

mlir/lib/IR/AsmPrinter.cpp

1900

Do you mean that we should have a F32Attr and F64Attr on top of FloatAttr?

[mehdi_amini]

Address comments and rebase

[mehdi_amini]

Move the definition of the base attr class to TableGen, and auto-generate the storage.

[mehdi_amini]

In D123774#3595059, @stellaraccident wrote:

Nice! Are the builtin dialect docs auto-generated somehow, or is there something we should update in this patch? (https://mlir.llvm.org/docs/Dialects/Builtin/#arrayattr)

Thanks for pointing it out, I forgot about this: just moved the definition to ODS, this will trigger the documentation update!

[mehdi_amini]

Minor cleanup (remove spurious fwd decls, move enum into the class)

[rriddle]

Looking great!

mlir/include/mlir/IR/BuiltinAttributes.h

69–71

Was the old comment over the 80 character limit?

mlir/include/mlir/IR/OpBase.td

1261–1266

You could likely define a base class for all of these that would remove most of the boilerplate:

class DenseArrayAttrBase<string denseAttrName, string cppType, string summaryName> :
    ElementsAttrBase<CPred<"$_self.isa<::mlir::" # denseAttrName # ">()">,
                     summaryName # "dense array attribute"> {
  let storageType = "::mlir::" # denseAttrName;
  let returnType = "::llvm::ArrayRef<" # cppType # ">";
}

def DenseI8ArrayAttr : DenseArrayAttrBase<"DenseI8ArrayAttr", "int8_t", "i8">;

or something similar.

mlir/lib/Parser/AttributeParser.cpp

83–85

if (parseCommaSeparatedListUntil(Token::r_square, parseElt))
  return nullptr;

?

828

I'll rebase and (formally) send out the patch that removes this sometime in the next week.

872

Missing a return after this?

879

Is this debugging?

mlir/lib/Parser/Parser.h

139–140

Leftover debugging?

mlir/test/IR/attribute.mlir

525

nit: Can we indent these checks to be inline with what they are checking?

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

289

nit: Extra newline?

[rriddle]

This looks like a good starting point to land and build on. (discussion on RFC seemed positive as well)

mlir/include/mlir/IR/BuiltinAttributes.td

183–184

The indent on these looks weird, missing an indent?

208–209

[mehdi_amini]

Address River's comments

mlir/include/mlir/IR/BuiltinAttributes.h

69–71

Looks like it! (81 chars)

mlir/lib/Parser/AttributeParser.cpp

879

indeed

[clementval]

I get a compilation error with this patch and gcc 9.1.0

/llvm-project/mlir/lib/IR/BuiltinAttributes.cpp:674:50: error: global qualification of class name is invalid before ':' token
  674 | struct ::mlir::detail::DenseArrayBaseAttrStorage : public AttributeStorage {

[clementval]

@mehdi_amini
Some buildbots are red -> https://lab.llvm.org/buildbot/#/builders/160/builds/7732

[Mogball]

mlir/lib/IR/AsmPrinter.cpp

1900

Yeah, and I32Attr and I64Attr, etc.

I was never a fan of the APInt/APInt APIs...

[mehdi_amini]

Sorry: pushed a fix and everything seems back to green now I think.

[clementval]

In D123774#3616234, @mehdi_amini wrote:

Sorry: pushed a fix and everything seems back to green now I think.

No worries. Thanks for the quick fix.

[lattner]

Awesome, I'm very excited about this. Out of curiosity, why did you invent a new [:i64 1, -2, 3] syntax rather than going with something more similar to dense<>, e.g. array<i64, 1, -2, 3>?

[mehdi_amini]

My initial proposal was ˋarrayref i64 [1, 2,3]` but after everyone chimed in we converged on this: it is inspired by ArrayAttr instead of DenseElementAttr, that is ArrayAttr is a list in between brackets and for this new DenseArrayAttr we only need to add the element type before the list.
We could have taken something inspired from dense elements attribute instead, I don’t see off hand and advantage to one or the other? The current one may be more concise though by avoiding a keyword (my initial proposal had a keyword).

[lattner]

Both work of course, it's more of a language "design" question than an engineering question.

The (very weak) argument I see in favor of array<..> is that it leads to a more readable and obvious textual format that isn't overloading syntax. [] already means a different kind of ArrayAttr. Having two different things have extremely similar syntax just makes it more confusing to reason and speak about. There is also a consistency argument with the more "aggregate packed" operations like dense<> etc.

That said, again, this is a weak argument, I think your approach here is also good. I'm thrilled to get this, I would love to see DenseElementAttr go away someday, it is crazy complicated.

[mehdi_amini]

It’s not too late to change this I think if you’d like: it just landed …

[lattner]

Ok, I'll expand my argument to see what you think. This is a bit of a braindump / ramble:

Looking at the parser comments, this is (allegedly: some things like affine_map are missing) what we had:

///  attribute-value ::= `unit`
///                    | bool-literal
///                    | integer-literal (`:` (index-type | integer-type))?
///                    | float-literal (`:` float-type)?
///                    | string-literal (`:` type)?
///                    | type
///                    | `[` (attribute-value (`,` attribute-value)*)? `]`
///                    | `{` (attribute-entry (`,` attribute-entry)*)? `}`
///                    | symbol-ref-id (`::` symbol-ref-id)*
///                    | `dense` `<` tensor-literal `>` `:`
///                      (tensor-type | vector-type)
///                    | `sparse` `<` attribute-value `,` attribute-value `>`
///                      `:` (tensor-type | vector-type)
///                    | `opaque` `<` dialect-namespace  `,` hex-string-literal
///                      `>` `:` (tensor-type | vector-type)
///                    | extended-attribute

I'd break this into five classes of syntactic constructs:

1. Primitives leaf things like true, 42, @bar, etc.
2. Types, like i32 and !basdf
3. Array/Dict aggregates that are [ ... ] and { ... }, these contain other attributes.
4. Other: dense<> sparse<> opaque<> affine_map<>, affine_set<> etc
5. Dialect attrs and forward refs #dialect<...> and #42

The argument I'm making is that this new "DenseArrayAttr" feels more it should inhabit category 4 from a lexical perspective, rather than category #3.

The major rationale is that it is not an aggregate of other attributes (intentionally). You can't iterate over its operands and get them as attributes (I mean, we could support that, but don't want to since that would be an attractive but inefficient footgun etc). It is more similar to the existing dense<> and sparse<> attributes (both of which I think are a mistake in hindsight), so putting them in that neighborhood feels right.

The one challenge I see with this is that the right name for this is "dense<>", but that is already taken. Using "array<>" would be the next best choice, but it is weird that array<> is not ArrayAttr. This confusion also infects the DenseArrayAttr name of the c++ class as well: this is really a thing that is conceptually different than ArrayAttr: it isn't just an array stored in dense form, it is also limited.

I'm not sure what the best thing to do is given we can't just nuke the existing dense<> thing from orbit :-). In a theoretical world I would argue that ArrayAttr is not the right name either: it should be ListAttr or something more generic since ArrayAttr supports heterogenous lists, but I'm not going to suggest we go there.

I see a couple practical paths on both the syntax and the C++ class naming:

?) Rename ArrayAttr -> ListAttr. This is somewhat unrelated to the other options.
a) Keep this as it is. I personally don't think this is right, but not enough to get in the way of progress if others do. I do think it is unfortunate that the DenseArrayAttr name is confusing with both ArrayAttr and DenseElementAttr in different ways.
b) Go with array<> and DenseArrayAttr. The problem with this is it admits confusion when talking about "an array attribute" verbally. We could use darray<> to be more similar to DenseArrayAttr.
c) Go with something new like blob<> and BlobAttr. The problem with this name is that blobs are generally untyped byte arrays, not homogenous arrays of dense elements.
d) Other name I'm not thinking about.

My preference would be option e), but I'm sure it would be controversial:

1. Resyntax dense<> to something like shaped_dense<> and rename DenseElementsAttr to ShapedDenseAttr since that is what it is.
2. SparseElementsAttr is not widely used in the MLIR tree, but if it is important, we'd rename it to ShapedSparseAttr and shaped_sparse<> to match the dense thing.
3. This new construct takes dense<> and DenseAttr as the names for this new thing
4. Everything is tidy and clearly differentiated, even if we don't rename ArrayAttr -> ListAttr (though that is probably still a reasonably good thing to do).

WDYT, clear as mud? @rriddle what are your thoughts here?

(edit: This previously spoke about "DenseTensorAttr", it was pointed out that DenseElementsAttr works with multidimension vectors too)

[Mogball]

dense can be vector-typed too, so I'm not sure calling it tensor is necessarily appropriate.

DenseArrayAttr rose out of the awkward API of DenseElementsAttr, so syntactically I would've expected it to look similar, like array<[0, 1, 2]> : vector<3xi32> but that's a real mouthful for something fundamentally simpler.

[jpienaar]

Good point about syntax and classes here. And it is true that this is introducing new way of specifying it (similar to how we specify op type, but not exact, so bending it a bit). We were (or at least I was) mostly thinking in terms of ArrayAttr as an array of Attributes (so the Type is homogeneous still, for the others that was just a much stricter requirement of homogeneous) and it's syntax.

Isn't there a (b') too, go with array and rename the other to ListAttr to avoid verbal confusion? (DenseElementAttr also allows for a vector there so dense_tensor is also not accurate, while dense_shaped_type is bleh unless we want to encourage it not being used ;-) It may be accurate for sparse though). I semi prefer array over dense, as dense tells me how something is storred but it doesn't really say what it is. blob makes me think of a bag of bits with interpretation up to use which I don't think we are there yet given the type specified (e.g., I feel there is a generic interpretation about the bits being made here).

There is also (f), use array, rename ArrayAttr to AttributeArrayAttr switch it and I32ArrayAttr and kin to use array in syntax and allow for Attribute along with int32_t, ... Just to make syntax more consistent. We could still rename dense and sparse of course.

[lattner]

Yes, you're right, I forgot about vectors, so s/Tensor/shaped/ in the names suggestions. I support the rename of ArrayAttr -> ListAttr, since it is more technically correct and avoids this sort of confusion. ArrayAttr is currently just as useful for a "struct-like" thing as it is for an "array like" thing. I edited the post above to reflect these corrections, thanks!

Jeff, I don't think there is any reason to ape the existing dense syntax outside the identifier<> structure. The other things (affine map, sparse, etc) all use their own syntax within the identifier<> structure that make sense for their domain.

In this case, the inner [] for dense is only because dense supports splatting, and isn't an issue here. Putting the type earlier in the list makes parsing much simpler, so going with somekeyword<ui32, 1, 2, 3, 4> seems totally fine. Do you disagree?

[Mogball]

Jeff, I don't think there is any reason to ape the existing dense syntax outside the identifier<> structure. The other things (affine map, sparse, etc) all use their own syntax within the identifier<> structure that make sense for their domain.

Ah, what I meant is that your argument for why DenseArrayAttr is category 3 and not 2 makes intuitive sense to me. I do agree that the square brackets would be redundant. But I don't like array<i32, 1, 2> because the type is visually in the same "list" as the elements. Having the type at the end is consistent with the rest of the built-in attributes anyways.

Putting the type earlier in the list makes parsing much simpler

The type is already passed into the attribute parser as the operation parser looks ahead for the trailing colon-type. This is how the type is passed into the parser for dense elements attributes.

array<1, 2, 3> : i32 would be easy to parse, although I'm not sure whether putting the element type as the type or vector<3xi32> would be better.

[lattner]

Yeah there is a minor issue of "this is the type of the element, not the type of the array", but the array doesn't have a type :-). I really don't think putting it into a vector type etc would be better, I think that would make the model more confusing.

What is the concern with putting the type inside the <>'s? This is how it is structured conceptually, so it makes sense to me. If you're worried about lexical confusion, maybe drop the first comma to array<i32 1, 2, 3>?

[lattner]

Could also go with something like array<i32: 1, 2, 3>

[rriddle]

In D123774#3631093, @lattner wrote:

Could also go with something like array<i32: 1, 2, 3>

This SGTM, and I agree with your assessment up thread about this being in the name<> category of attributes.

[jpienaar]

In D123774#3631094, @rriddle wrote:

In D123774#3631093, @lattner wrote:

Could also go with something like array<i32: 1, 2, 3>

This SGTM, and I agree with your assessment up thread about this being in the name<> category of attributes.

+1 from me too (I like the : more than , )

[silvas]

+1 on confusion of DenseArrayAttr with ArrayAttr and DenseElementsAttr in the C++ API. It will be hard to keep those straight.

mlir/include/mlir/IR/BuiltinAttributes.h

 };
 
 /// Type trait detector that checks if a given type T is a complex type.
 template <typename T> struct is_complex_t : public std::false_type {};
 template <typename T>
 struct is_complex_t<std::complex<T>> : public std::true_type {};
 } // namespace detail
 
-/// An attribute that represents a reference to a dense vector or tensor object.
-///
+/// An attribute that represents a reference to a dense vector or tensor
+/// object.
 class DenseElementsAttr : public Attribute {
 public:
   using Attribute::Attribute;
 
   /// Allow implicit conversion to ElementsAttr.
   operator ElementsAttr() const {
     return *this ? cast<ElementsAttr>() : nullptr;
   }
 
   /// Type trait used to check if the given type T is a potentially valid C++
   /// floating point type that can be used to access the underlying element
   /// types of a DenseElementsAttr.
   // TODO: Use std::disjunction when C++17 is supported.
   template <typename T> struct is_valid_cpp_fp_type {
     /// The type is a valid floating point type if it is a builtin floating
     /// point type, or is a potentially user defined floating point type. The
     /// latter allows for supporting users that have custom types defined for
     /// bfloat16/half/etc.
     static constexpr bool value = llvm::is_one_of<T, float, double>::value ||
                                   (std::numeric_limits<T>::is_specialized &&
                                    !std::numeric_limits<T>::is_integer);
   };
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
 
   /// Constructs a dense elements attribute from an array of element values.
   /// Each element attribute value is expected to be an element of 'type'.
   /// 'type' must be a vector or tensor with static shape. If the element of
   /// `type` is non-integer/index/float it is assumed to be a string type.
   static DenseElementsAttr get(ShapedType type, ArrayRef<Attribute> values);
 
   /// Constructs a dense integer elements attribute from an array of integer
   /// or floating-point values. Each value is expected to be the same bitwidth
   /// of the element type of 'type'. 'type' must be a vector or tensor with
   /// static shape.
   template <typename T, typename = typename std::enable_if<
                             std::numeric_limits<T>::is_integer ||
                             is_valid_cpp_fp_type<T>::value>::type>
   static DenseElementsAttr get(const ShapedType &type, ArrayRef<T> values) {
     const char *data = reinterpret_cast<const char *>(values.data());
     return getRawIntOrFloat(
         type, ArrayRef<char>(data, values.size() * sizeof(T)), sizeof(T),
         std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed);
   }
 
   /// Constructs a dense integer elements attribute from a single element.
   template <typename T, typename = typename std::enable_if<
                             std::numeric_limits<T>::is_integer ||
                             is_valid_cpp_fp_type<T>::value ||
                             detail::is_complex_t<T>::value>::type>
   static DenseElementsAttr get(const ShapedType &type, T value) {
     return get(type, llvm::makeArrayRef(value));
   }
 
   /// Constructs a dense complex elements attribute from an array of complex
   /// values. Each value is expected to be the same bitwidth of the element type
   /// of 'type'. 'type' must be a vector or tensor with static shape.
   template <typename T, typename ElementT = typename T::value_type,
             typename = typename std::enable_if<
                 detail::is_complex_t<T>::value &&
                 (std::numeric_limits<ElementT>::is_integer ||
                  is_valid_cpp_fp_type<ElementT>::value)>::type>
   static DenseElementsAttr get(const ShapedType &type, ArrayRef<T> values) {
     const char *data = reinterpret_cast<const char *>(values.data());
     return getRawComplex(type, ArrayRef<char>(data, values.size() * sizeof(T)),
                          sizeof(T), std::numeric_limits<ElementT>::is_integer,
                          std::numeric_limits<ElementT>::is_signed);
   }
 
   /// Overload of the above 'get' method that is specialized for boolean values.

 #define GET_ATTRDEF_CLASSES
 #include "mlir/IR/BuiltinAttributes.h.inc"
 
 //===----------------------------------------------------------------------===//
 // C++ Attribute Declarations
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
+namespace detail {
+/// Base class for DenseArrayAttr that is instantiated and specialized for each
+/// supported element type below.
+template <typename T>
+class DenseArrayAttr : public DenseArrayBaseAttr {
+public:
+  using DenseArrayBaseAttr::DenseArrayBaseAttr;
+
+  /// Implicit conversion to ArrayRef<T>.
+  operator ArrayRef<T>() const;
+  ArrayRef<T> asArrayRef() { return ArrayRef<T>{*this}; }
+
+  /// Builder from ArrayRef<T>.
+  static DenseArrayAttr get(MLIRContext *context, ArrayRef<T> content);
+
+  /// Print the short form `[42, 100, -1]` without any type prefix.
+  void print(AsmPrinter &printer) const;
+  void print(raw_ostream &os) const;
+  /// Print the short form `42, 100, -1` without any braces or type prefix.
+  void printWithoutBraces(raw_ostream &os) const;
+
+  /// Parse the short form `[42, 100, -1]` without any type prefix.
+  static Attribute parse(AsmParser &parser, Type odsType);
+
+  /// Parse the short form `42, 100, -1` without any type prefix or braces.
+  static Attribute parseWithoutBraces(AsmParser &parser, Type odsType);
+
+  /// Support for isa<>/cast<>.
+  static bool classof(Attribute attr);
+};
+template <>
+void DenseArrayAttr<int8_t>::printWithoutBraces(raw_ostream &os) const;
+
+extern template class DenseArrayAttr<int8_t>;
+extern template class DenseArrayAttr<int16_t>;
+extern template class DenseArrayAttr<int32_t>;
+extern template class DenseArrayAttr<int64_t>;
+extern template class DenseArrayAttr<float>;
+extern template class DenseArrayAttr<double>;
+} // namespace detail
+
+// Public name for all the supported DenseArrayAttr
+using DenseI8ArrayAttr = detail::DenseArrayAttr<int8_t>;
+using DenseI16ArrayAttr = detail::DenseArrayAttr<int16_t>;
+using DenseI32ArrayAttr = detail::DenseArrayAttr<int32_t>;
+using DenseI64ArrayAttr = detail::DenseArrayAttr<int64_t>;
+using DenseF32ArrayAttr = detail::DenseArrayAttr<float>;
+using DenseF64ArrayAttr = detail::DenseArrayAttr<double>;
+
 //===----------------------------------------------------------------------===//
 // BoolAttr
 //===----------------------------------------------------------------------===//
 
 /// Special case of IntegerAttr to represent boolean integers, i.e., signless i1
 /// integers.
 class BoolAttr : public Attribute {
 public:

mlir/include/mlir/IR/BuiltinAttributes.td

public:
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // DenseIntOrFPElementsAttr
 //===----------------------------------------------------------------------===//
 
+def Builtin_DenseArrayBase : Builtin_Attr<
+    "DenseArrayBase", [ElementsAttrInterface]> {
+  let summary = "A dense array of i8, i16, i32, i64, f32, or f64.";
+  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>`. This is the base class attribute, the actual access is
+    intended to be managed through the subclasses `DenseI8ArrayAttr`,
+    `DenseI16ArrayAttr`, `DenseI32ArrayAttr`, `DenseI64ArrayAttr`,
+    `DenseF32ArrayAttr`, and `DenseF64ArrayAttr`.
+
+    Syntax:
+
+    ```
+    dense-array-attribute ::= `[` `:` (integer-type | float-type) tensor-literal `]`
+    ```
+    Examples:
+
+    ```mlir
+    [:i8]
+    [:i32 10, 42]
+    [: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]
+    ```
+  }];
+  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
+                        "DenseArrayBaseAttr::EltType":$eltType,
+                        ArrayRefParameter<"char">:$elements);
+  let extraClassDeclaration = [{
+    // All possible supported element type.
+    enum class EltType { I8, I16, I32, I64, F32, F64 };
+
+    /// Allow implicit conversion to ElementsAttr.
+    operator ElementsAttr() const {
+      return *this ? cast<ElementsAttr>() : nullptr;
+    }
+
+    /// ElementsAttr implementation.
+    using ContiguousIterableTypesT =
+        std::tuple<int8_t, int16_t, int32_t, int64_t, float, double>;
+    const int8_t *value_begin_impl(OverloadToken<int8_t>) const;
+    const int16_t *value_begin_impl(OverloadToken<int16_t>) const;
+    const int32_t *value_begin_impl(OverloadToken<int32_t>) const;
+    const int64_t *value_begin_impl(OverloadToken<int64_t>) const;
+    const float *value_begin_impl(OverloadToken<float>) const;
+    const double *value_begin_impl(OverloadToken<double>) const;
+
+    /// Methods to support type inquiry through isa, cast, and dyn_cast.
+    EltType getElementType() const;
+    /// Printer for the short form: will dispatch to the appropriate subclass.
+    void print(AsmPrinter &printer) const;
+    void print(raw_ostream &os) const;
+    /// Print the short form `42, 100, -1` without any braces or prefix.
+    void printWithoutBraces(raw_ostream &os) const;
+  }];
+  let genAccessors = 0;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// DenseIntOrFPElementsAttr
+//===----------------------------------------------------------------------===//
+
 def Builtin_DenseIntOrFPElementsAttr : Builtin_Attr<
     "DenseIntOrFPElements", [ElementsAttrInterface], "DenseElementsAttr"
   > {
   let summary = "An Attribute containing a dense multi-dimensional array of "
                 "integer or floating-point values";
   let description = [{
     Syntax:
 

mlir/include/mlir/IR/OpBase.td

ElementsAttrBase<And<[CPred<"$_self.isa<::mlir::DenseIntElementsAttr>()">,
                           condition]>,
                      summary> {
   let storageType = [{ ::mlir::DenseIntElementsAttr }];
   let returnType = [{ ::mlir::DenseIntElementsAttr }];
 
   let convertFromStorage = "$_self";
 }
 
+class DenseArrayAttrBase<string denseAttrName, string cppType, string summaryName> :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::" # denseAttrName # ">()">,
+                     summaryName # " dense array attribute"> {
+  let storageType = "::mlir::" # denseAttrName;
+  let returnType = "::llvm::ArrayRef<" # cppType # ">";
+}
+def DenseI8ArrayAttr : DenseArrayAttrBase<"DenseI8ArrayAttr", "int8_t", "i8">;
+def DenseI16ArrayAttr : DenseArrayAttrBase<"DenseI16ArrayAttr", "int16_t", "i16">;
+def DenseI32ArrayAttr : DenseArrayAttrBase<"DenseI32ArrayAttr", "int32_t", "i32">;
+def DenseI64ArrayAttr : DenseArrayAttrBase<"DenseI64ArrayAttr", "int64_t", "i64">;
+def DenseF32ArrayAttr : DenseArrayAttrBase<"DenseF32ArrayAttr", "float", "f32">;
+def DenseF64ArrayAttr : DenseArrayAttrBase<"DenseF64ArrayAttr", "double", "f64">;
+
 def IndexElementsAttr
     : IntElementsAttrBase<CPred<[{$_self.cast<::mlir::DenseIntElementsAttr>()
                                       .getType()
                                       .getElementType()
                                       .isIndex()}]>,
                           "index elements attribute">;
 
 def AnyIntElementsAttr : IntElementsAttrBase<CPred<"true">, "integer elements attribute">;

mlir/lib/IR/AsmPrinter.cpp

if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
       DenseIntElementsAttr indices = sparseEltAttr.getIndices();
       if (indices.getNumElements() != 0) {
         printDenseIntOrFPElementsAttr(indices, /*allowHex=*/false);
         os << ", ";
         printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
       }
       os << '>';
     }
-
+  } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayBaseAttr>()) {
+    typeElision = AttrTypeElision::Must;
+    switch (denseArrayAttr.getElementType()) {
+    case DenseArrayBaseAttr::EltType::I8:
+      os << "[:i8 ";
+      break;
+    case DenseArrayBaseAttr::EltType::I16:
+      os << "[:i16 ";
+      break;
+    case DenseArrayBaseAttr::EltType::I32:
+      os << "[:i32 ";
+      break;
+    case DenseArrayBaseAttr::EltType::I64:
+      os << "[:i64 ";
+      break;
+    case DenseArrayBaseAttr::EltType::F32:
+      os << "[:f32 ";
+      break;
+    case DenseArrayBaseAttr::EltType::F64:
+      os << "[:f64 ";
+      break;
+    }
+    denseArrayAttr.printWithoutBraces(os);
+    os << "]";
   } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
     printLocation(locAttr);
+  } else {
+    llvm::report_fatal_error("Unknown builtin attribute");
   }
   // Don't print the type if we must elide it, or if it is a None type.
   if (typeElision != AttrTypeElision::Must && !attrType.isa<NoneType>()) {
     os << " : ";
     printType(attrType);
   }
 }
 

mlir/lib/IR/BuiltinAttributes.cpp

 //===- BuiltinAttributes.cpp - MLIR Builtin Attribute Classes -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinAttributes.h"
 #include "AttributeDetail.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/IntegerSet.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/DecodeAttributesInterfaces.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/Support/Endian.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 /// Tablegen Attribute Definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/IR/BuiltinAttributes.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // BuiltinDialect
 //===----------------------------------------------------------------------===//
 
 void BuiltinDialect::registerAttributes() {
-  addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
-                DenseStringElementsAttr, DictionaryAttr, FloatAttr,
-                SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
-                OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
-                UnitAttr>();
+  addAttributes<AffineMapAttr, ArrayAttr, DenseArrayBaseAttr,
+                DenseIntOrFPElementsAttr, DenseStringElementsAttr,
+                DictionaryAttr, FloatAttr, SymbolRefAttr, IntegerAttr,
+                IntegerSetAttr, OpaqueAttr, OpaqueElementsAttr,
+                SparseElementsAttr, StringAttr, TypeAttr, UnitAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAttr
 //===----------------------------------------------------------------------===//
 
 void ArrayAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,

 DenseElementsAttr::ComplexIntElementIterator::operator*() const {
   size_t storageWidth = getDenseElementStorageWidth(bitWidth);
   size_t offset = getDataIndex() * storageWidth * 2;
   return {readBits(getData(), offset, bitWidth),
           readBits(getData(), offset + storageWidth, bitWidth)};
 }
 
 //===----------------------------------------------------------------------===//
+// DenseArrayAttr
+//===----------------------------------------------------------------------===//
+
+DenseArrayBaseAttr::EltType DenseArrayBaseAttr::getElementType() const {
+  return getImpl()->eltType;
+}
+
+const int8_t *
+DenseArrayBaseAttr::value_begin_impl(OverloadToken<int8_t>) const {
+  return cast<DenseI8ArrayAttr>().asArrayRef().begin();
+}
+const int16_t *
+DenseArrayBaseAttr::value_begin_impl(OverloadToken<int16_t>) const {
+  return cast<DenseI16ArrayAttr>().asArrayRef().begin();
+}
+const int32_t *
+DenseArrayBaseAttr::value_begin_impl(OverloadToken<int32_t>) const {
+  return cast<DenseI32ArrayAttr>().asArrayRef().begin();
+}
+const int64_t *
+DenseArrayBaseAttr::value_begin_impl(OverloadToken<int64_t>) const {
+  return cast<DenseI64ArrayAttr>().asArrayRef().begin();
+}
+const float *DenseArrayBaseAttr::value_begin_impl(OverloadToken<float>) const {
+  return cast<DenseF32ArrayAttr>().asArrayRef().begin();
+}
+const double *
+DenseArrayBaseAttr::value_begin_impl(OverloadToken<double>) const {
+  return cast<DenseF64ArrayAttr>().asArrayRef().begin();
+}
+
+void DenseArrayBaseAttr::print(AsmPrinter &printer) const {
+  print(printer.getStream());
+}
+
+void DenseArrayBaseAttr::printWithoutBraces(raw_ostream &os) const {
+  switch (getElementType()) {
+  case DenseArrayBaseAttr::EltType::I8:
+    this->cast<DenseI8ArrayAttr>().printWithoutBraces(os);
+    return;
+  case DenseArrayBaseAttr::EltType::I16:
+    this->cast<DenseI16ArrayAttr>().printWithoutBraces(os);
+    return;
+  case DenseArrayBaseAttr::EltType::I32:
+    this->cast<DenseI32ArrayAttr>().printWithoutBraces(os);
+    return;
+  case DenseArrayBaseAttr::EltType::I64:
+    this->cast<DenseI64ArrayAttr>().printWithoutBraces(os);
+    return;
+  case DenseArrayBaseAttr::EltType::F32:
+    this->cast<DenseF32ArrayAttr>().printWithoutBraces(os);
+    return;
+  case DenseArrayBaseAttr::EltType::F64:
+    this->cast<DenseF64ArrayAttr>().printWithoutBraces(os);
+    return;
+  }
+  llvm_unreachable("<unknown DenseArrayBaseAttr>");
+}
+
+void DenseArrayBaseAttr::print(raw_ostream &os) const {
+  os << "[";
+  printWithoutBraces(os);
+  os << "]";
+}
+
+template <typename T>
+void DenseArrayAttr<T>::print(AsmPrinter &printer) const {
+  print(printer.getStream());
+}
+
+template <typename T>
+void DenseArrayAttr<T>::printWithoutBraces(raw_ostream &os) const {
+  ArrayRef<T> values{*this};
+  llvm::interleaveComma(values, os);
+}
+
+/// Specialization for int8_t for forcing printing as number instead of chars.
+template <>
+void DenseArrayAttr<int8_t>::printWithoutBraces(raw_ostream &os) const {
+  ArrayRef<int8_t> values{*this};
+  llvm::interleaveComma(values, os, [&](int64_t v) { os << v; });
+}
+
+template <typename T>
+void DenseArrayAttr<T>::print(raw_ostream &os) const {
+  os << "[";
+  printWithoutBraces(os);
+  os << "]";
+}
+
+/// Parse a single element: generic template for int types, specialized for
+/// floating points below.
+template <typename T>
+static ParseResult parseDenseArrayAttrElt(AsmParser &parser, T &value) {
+  return parser.parseInteger(value);
+}
+
+template <>
+ParseResult parseDenseArrayAttrElt<float>(AsmParser &parser, float &value) {
+  double doubleVal;
+  if (parser.parseFloat(doubleVal))
+    return failure();
+  value = doubleVal;
+  return success();
+}
+
+template <>
+ParseResult parseDenseArrayAttrElt<double>(AsmParser &parser, double &value) {
+  return parser.parseFloat(value);
+}
+
+/// Parse a DenseArrayAttr without the braces: `1, 2, 3`
+template <typename T>
+Attribute DenseArrayAttr<T>::parseWithoutBraces(AsmParser &parser,
+                                                Type odsType) {
+  SmallVector<T> data;
+  if (failed(parser.parseCommaSeparatedList([&]() {
+        T value;
+        if (parseDenseArrayAttrElt(parser, value))
+          return failure();
+        data.push_back(value);
+        return success();
+      })))
+    return {};
+  return get(parser.getContext(), data);
+}
+
+/// Parse a DenseArrayAttr: `[ 1, 2, 3 ]`
+template <typename T>
+Attribute DenseArrayAttr<T>::parse(AsmParser &parser, Type odsType) {
+  if (parser.parseLSquare())
+    return {};
+  Attribute result = parseWithoutBraces(parser, odsType);
+  if (parser.parseRSquare())
+    return {};
+  return result;
+}
+
+/// Conversion from DenseArrayAttr<T> to ArrayRef<T>.
+template <typename T>
+DenseArrayAttr<T>::operator ArrayRef<T>() const {
+  ArrayRef<char> raw = getImpl()->elements;
+  assert((raw.size() % sizeof(T)) == 0);
+  return ArrayRef<T>(reinterpret_cast<const T *>(raw.data()),
+                     raw.size() / sizeof(T));
+}
+
+namespace {
+/// Mapping from C++ element type to MLIR DenseArrayAttr internals.
+template <typename T>
+struct denseArrayAttrEltTypeBuilder;
+template <>
+struct denseArrayAttrEltTypeBuilder<int8_t> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I8;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, IntegerType::get(context, 8));
+  }
+};
+template <>
+struct denseArrayAttrEltTypeBuilder<int16_t> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I16;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, IntegerType::get(context, 16));
+  }
+};
+template <>
+struct denseArrayAttrEltTypeBuilder<int32_t> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I32;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, IntegerType::get(context, 32));
+  }
+};
+template <>
+struct denseArrayAttrEltTypeBuilder<int64_t> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I64;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, IntegerType::get(context, 64));
+  }
+};
+template <>
+struct denseArrayAttrEltTypeBuilder<float> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::F32;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, Float32Type::get(context));
+  }
+};
+template <>
+struct denseArrayAttrEltTypeBuilder<double> {
+  constexpr static auto eltType = DenseArrayBaseAttr::EltType::F64;
+  static ShapedType getShapedType(MLIRContext *context, int64_t shape) {
+    return VectorType::get(shape, Float64Type::get(context));
+  }
+};
+} // namespace
+
+/// Builds a DenseArrayAttr<T> from an ArrayRef<T>.
+template <typename T>
+DenseArrayAttr<T> DenseArrayAttr<T>::get(MLIRContext *context,
+                                         ArrayRef<T> content) {
+  auto shapedType =
+      denseArrayAttrEltTypeBuilder<T>::getShapedType(context, content.size());
+  auto eltType = denseArrayAttrEltTypeBuilder<T>::eltType;
+  auto rawArray = ArrayRef<char>(reinterpret_cast<const char *>(content.data()),
+                                 content.size() * sizeof(T));
+  return Base::get(context, shapedType, eltType, rawArray)
+      .template cast<DenseArrayAttr<T>>();
+}
+
+template <typename T>
+bool DenseArrayAttr<T>::classof(Attribute attr) {
+  return attr.isa<DenseArrayBaseAttr>() &&
+         attr.cast<DenseArrayBaseAttr>().getElementType() ==
+             denseArrayAttrEltTypeBuilder<T>::eltType;
+}
+
+namespace mlir {
+namespace detail {
+// Explicit instantiation for all the supported DenseArrayAttr.
+template class DenseArrayAttr<int8_t>;
+template class DenseArrayAttr<int16_t>;
+template class DenseArrayAttr<int32_t>;
+template class DenseArrayAttr<int64_t>;
+template class DenseArrayAttr<float>;
+template class DenseArrayAttr<double>;
+} // namespace detail
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
 // DenseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Method for support type inquiry through isa, cast and dyn_cast.
 bool DenseElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>();
 }
 

mlir/lib/Parser/AttributeParser.cpp

 //===- AttributeParser.cpp - MLIR Attribute Parser Implementation ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the parser for the MLIR Types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Parser.h"
+
+#include "AsmParserImpl.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Parser/AsmParserState.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Endian.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 /// Parse an arbitrary attribute.
 ///
 ///  attribute-value ::= `unit`
 ///                    | bool-literal
 ///                    | integer-literal (`:` (index-type | integer-type))?
 ///                    | float-literal (`:` float-type)?
 ///                    | string-literal (`:` type)?
 ///                    | type
+///                    | `[` `:` (integer-type | float-type) tensor-literal `]`
 ///                    | `[` (attribute-value (`,` attribute-value)*)? `]`
 ///                    | `{` (attribute-entry (`,` attribute-entry)*)? `}`
 ///                    | symbol-ref-id (`::` symbol-ref-id)*
 ///                    | `dense` `<` tensor-literal `>` `:`
 ///                      (tensor-type | vector-type)
 ///                    | `sparse` `<` attribute-value `,` attribute-value `>`
 ///                      `:` (tensor-type | vector-type)
 ///                    | `opaque` `<` dialect-namespace  `,` hex-string-literal
 ///                      `>` `:` (tensor-type | vector-type)
 ///                    | extended-attribute
 ///
 Attribute Parser::parseAttribute(Type type) {
   switch (getToken().getKind()) {
   // Parse an AffineMap or IntegerSet attribute.
if (parseToken(Token::less, "expected '<' in integer set") ||
         parseIntegerSetReference(set) ||
         parseToken(Token::greater, "expected '>' in integer set"))
       return Attribute();
     return IntegerSetAttr::get(set);
   }
 
   // Parse an array attribute.
   case Token::l_square: {
+    consumeToken(Token::l_square);
+    if (consumeIf(Token::colon))
+      return parseDenseArrayAttr();
     SmallVector<Attribute, 4> elements;
     auto parseElt = [&]() -> ParseResult {
       elements.push_back(parseAttribute());
       return elements.back() ? success() : failure();
     };
 
-    if (parseCommaSeparatedList(Delimiter::Square, parseElt))
+    if (parseCommaSeparatedListUntil(Token::r_square, parseElt))
       return nullptr;
     return builder.getArrayAttr(elements);
   }
 
   // Parse a boolean attribute.
   case Token::kw_false:
     consumeToken(Token::kw_false);
     return builder.getBoolAttr(false);
   case Token::kw_true:
     consumeToken(Token::kw_true);
ParseResult TensorLiteralParser::parseList(SmallVectorImpl<int64_t> &dims) {
   dims.append(newDims.begin(), newDims.end());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ElementsAttr Parser
 //===----------------------------------------------------------------------===//
 
+namespace {
+/// This class provides an implementation of AsmParser, allowing to call back
+/// into the libMLIRIR-provided APIs for invoking attribute parsing code defined
+/// in libMLIRIR.
+class CustomAsmParser : public AsmParserImpl<AsmParser> {
+public:
+  CustomAsmParser(Parser &parser)
+      : AsmParserImpl<AsmParser>(parser.getToken().getLoc(), parser) {}
+};
+} // namespace
+
+/// Parse a dense array attribute.
+Attribute Parser::parseDenseArrayAttr() {
+  auto typeLoc = getToken().getLoc();
+  auto type = parseType();
+  if (!type)
+    return {};
+  CustomAsmParser parser(*this);
+  Attribute result;
+  if (auto intType = type.dyn_cast<IntegerType>()) {
+    switch (type.getIntOrFloatBitWidth()) {
+    case 8:
+      result = DenseI8ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    case 16:
+      result = DenseI16ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    case 32:
+      result = DenseI32ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    case 64:
+      result = DenseI64ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    default:
+      emitError(typeLoc, "expected i8, i16, i32, or i64 but got: ") << type;
+      return {};
+    }
+  } else if (auto floatType = type.dyn_cast<FloatType>()) {
+    switch (type.getIntOrFloatBitWidth()) {
+    case 32:
+      result = DenseF32ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    case 64:
+      result = DenseF64ArrayAttr::parseWithoutBraces(parser, Type{});
+      break;
+    default:
+      emitError(typeLoc, "expected f32 or f64 but got: ") << type;
+      return {};
+    }
+  } else {
+    emitError(typeLoc, "expected integer or float type, got: ") << type;
+    return {};
+  }
+  if (!consumeIf(Token::r_square)) {
+    emitError("expected ']' to close an array attribute");
+    return {};
+  }
+  return result;
+}
+
 /// 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;
 
   // Parse the literal data if necessary.

mlir/lib/Parser/Parser.h

assert(state.curToken.isNot(Token::eof, Token::error) &&
            "shouldn't advance past EOF or errors");
     state.curToken = state.lex.lexToken();
   }
 
   /// Advance the current lexer onto the next token, asserting what the expected
   /// current token is.  This is preferred to the above method because it leads
   /// to more self-documenting code with better checking.
   void consumeToken(Token::Kind kind) {
     assert(state.curToken.is(kind) && "consumed an unexpected token");
     consumeToken();
   }
 
   /// Consume the specified token if present and return success.  On failure,
   /// output a diagnostic and return failure.
   ParseResult parseToken(Token::Kind expectedToken, const Twine &message);
 
   /// Parse an optional integer value from the stream.
   OptionalParseResult parseOptionalInteger(APInt &result);
public:
 
   /// Parse an opaque elements attribute.
   Attribute parseOpaqueElementsAttr(Type attrType);
 
   /// Parse a dense elements attribute.
   Attribute parseDenseElementsAttr(Type attrType);
   ShapedType parseElementsLiteralType(Type type);
 
+  /// Parse a DenseArrayAttr.
+  Attribute parseDenseArrayAttr();
+
   /// Parse a sparse elements attribute.
   Attribute parseSparseElementsAttr(Type attrType);
 
   //===--------------------------------------------------------------------===//
   // Location Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a raw location instance.

mlir/test/IR/attribute.mlir

 func.func @simple_scalar_example() {
   "test.string_elements_attr"() {
     // CHECK: dense<["example1", "example2"]>
     scalar_string_attr = dense<["example1", "example2"]> : tensor<2x!unknown<"">>
   } : () -> ()
   return
 }
 
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Test DenseArrayAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: func @dense_array_attr
+func.func @dense_array_attr() attributes{ 
+// CHECK-SAME: f32attr = [:f32 1.024000e+03, 4.530000e+02, -6.435000e+03],
+               f32attr = [:f32 1024., 453., -6435.],
+// CHECK-SAME: f64attr = [:f64 -1.420000e+02],
+               f64attr = [:f64 -142.],
+// CHECK-SAME: i16attr = [:i16 3, 5, -4, 10],
+               i16attr = [:i16 3, 5, -4, 10],
+// CHECK-SAME: i32attr = [:i32 1024, 453, -6435],
+               i32attr = [:i32 1024, 453, -6435],
+// CHECK-SAME: i64attr = [:i64 -142],
+               i64attr = [:i64 -142],
+// CHECK-SAME: i8attr = [:i8 1, -2, 3]
+               i8attr = [:i8 1, -2, 3]
+ } {
+// CHECK:  test.dense_array_attr
+  test.dense_array_attr
+// CHECK-SAME: i8attr = [1, -2, 3]
+               i8attr = [1, -2, 3]
+// CHECK-SAME: i16attr = [3, 5, -4, 10]
+               i16attr = [3, 5, -4, 10]
+// CHECK-SAME: i32attr = [1024, 453, -6435]
+               i32attr = [1024, 453, -6435]
+// CHECK-SAME: i64attr = [-142]
+               i64attr = [-142]
+// CHECK-SAME: f32attr = [1.024000e+03, 4.530000e+02, -6.435000e+03]
+               f32attr = [1024., 453., -6435.]
+// CHECK-SAME: f64attr = [-1.420000e+02]
+               f64attr = [-142.]
+  return
+}
+
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 func.func @fn() { return }
 

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

 // RUN: mlir-opt %s -test-elements-attr-interface -verify-diagnostics
 
 // This test contains various `ElementsAttr` attributes, and tests the support
 // for iterating the values of these attributes using various native C++ types.
 // This tests that the abstract iteration of ElementsAttr works properly, and
 // is properly failable when necessary.
 
+// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
 // expected-error@below {{Test iterating `uint64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `APInt`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `IntegerAttr`: 10 : i64, 11 : i64, 12 : i64, 13 : i64, 14 : i64}}
 arith.constant #test.i64_elements<[10, 11, 12, 13, 14]> : tensor<5xi64>
 
+// expected-error@below {{Test iterating `int64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `uint64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `APInt`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `IntegerAttr`: 10 : i64, 11 : i64, 12 : i64, 13 : i64, 14 : i64}}
 arith.constant dense<[10, 11, 12, 13, 14]> : tensor<5xi64>
 
+// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
 // expected-error@below {{Test iterating `uint64_t`: unable to iterate type}}
 // expected-error@below {{Test iterating `APInt`: unable to iterate type}}
 // expected-error@below {{Test iterating `IntegerAttr`: unable to iterate type}}
 arith.constant opaque<"_", "0xDEADBEEF"> : tensor<5xi64>
 
 // 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 `int8_t`: 10, 11, -12, 13, 14}}
+arith.constant [:i8 10, 11, -12, 13, 14]
+// expected-error@below {{Test iterating `int16_t`: 10, 11, -12, 13, 14}}
+arith.constant [:i16 10, 11, -12, 13, 14]
+// expected-error@below {{Test iterating `int32_t`: 10, 11, -12, 13, 14}}
+arith.constant [:i32 10, 11, -12, 13, 14]
+// expected-error@below {{Test iterating `int64_t`: 10, 11, -12, 13, 14}}
+arith.constant [:i64 10, 11, -12, 13, 14]
+// expected-error@below {{Test iterating `float`: 10.00, 11.00, -12.00, 13.00, 14.00}}
+arith.constant [:f32 10., 11., -12., 13., 14.]
+// expected-error@below {{Test iterating `double`: 10.00, 11.00, -12.00, 13.00, 14.00}}
+arith.constant [:f64 10., 11., -12., 13., 14.]

mlir/test/IR/invalid.mlir

 
 // -----
 
 // expected-error@+1 {{expected valid attribute name}}
 "t"(){""}
 
 // -----
 
-// expected-error@+1 {{expected ']'}}
+// expected-error@+1 {{expected ',' or ']'}}
 "f"() { b = [@m:
 
 // -----
 
 // This makes sure we emit an error at the end of the correct line, the : is
 // expected at the end of foo, not on the return line.
 func.func @error_at_end_of_line() {
   // expected-error@+1 {{expected ':' followed by operation type}}

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

 }
 
 def StringElementsAttrOp : TEST_Op<"string_elements_attr"> {
   let arguments = (ins
       StringElementsAttr:$scalar_string_attr
   );
 }
 
+def DenseArrayAttrOp : TEST_Op<"dense_array_attr"> {
+  let arguments = (ins
+    DenseI8ArrayAttr:$i8attr,
+    DenseI16ArrayAttr:$i16attr,
+    DenseI32ArrayAttr:$i32attr,
+    DenseI64ArrayAttr:$i64attr,
+    DenseF32ArrayAttr:$f32attr,
+    DenseF64ArrayAttr:$f64attr
+  );
+  let assemblyFormat = [{
+   `i8attr` `=` $i8attr `i16attr` `=` $i16attr `i32attr` `=` $i32attr
+   `i64attr` `=` $i64attr  `f32attr` `=` $f32attr `f64attr` `=` $f64attr
+   attr-dict
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Test Enum Attributes
 //===----------------------------------------------------------------------===//
 
 // Define the C++ enum.
 def TestEnum
     : I32EnumAttr<"TestEnum", "a test enum", [
         I32EnumAttrCase<"First", 0, "first">,
         I32EnumAttrCase<"Second", 1, "second">,

mlir/test/lib/IR/TestBuiltinAttributeInterfaces.cpp

 //===- TestBuiltinAttributeInterfaces.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace mlir;
 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<DenseArrayBaseAttr>()) {
+          switch (concreteAttr.getElementType()) {
+          case DenseArrayBaseAttr::EltType::I8:
+            testElementsAttrIteration<int8_t>(op, elementsAttr, "int8_t");
+            break;
+          case DenseArrayBaseAttr::EltType::I16:
+            testElementsAttrIteration<int16_t>(op, elementsAttr, "int16_t");
+            break;
+          case DenseArrayBaseAttr::EltType::I32:
+            testElementsAttrIteration<int32_t>(op, elementsAttr, "int32_t");
+            break;
+          case DenseArrayBaseAttr::EltType::I64:
+            testElementsAttrIteration<int64_t>(op, elementsAttr, "int64_t");
+            break;
+          case DenseArrayBaseAttr::EltType::F32:
+            testElementsAttrIteration<float>(op, elementsAttr, "float");
+            break;
+          case DenseArrayBaseAttr::EltType::F64:
+            testElementsAttrIteration<double>(op, elementsAttr, "double");
+            break;
+          }
+          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");
       }
     });
   }
 
   template <typename T>
   void testElementsAttrIteration(Operation *op, ElementsAttr attr,
                                  StringRef type) {
     InFlightDiagnostic diag = op->emitError()
                               << "Test iterating `" << type << "`: ";
 
     auto values = attr.tryGetValues<T>();
     if (!values) {
       diag << "unable to iterate type";
       return;
     }
 
-    llvm::interleaveComma(*values, diag, [&](T value) {
-      diag << llvm::formatv("{0}", value).str();
-    });
+    llvm::interleaveComma(*values, diag,
+                          [&](T value) { printOneElement(diag, value); });
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestBuiltinAttributeInterfaces() {
   PassRegistration<TestElementsAttrInterface>();
 }
 } // namespace test
 } // namespace mlir