[mlir] Remove the element type enum from DenseArrayAttr

[Mogball]

Summary

The element type enum is not needed to differentiate dense array kinds
because the element type of the shaped type can be used instead.

[mehdi_amini]

mlir/include/mlir/IR/BuiltinAttributes.td

190

Why didn't we declare the type as "RankedTensor" here?

[rriddle]

mlir/lib/IR/BuiltinAttributes.cpp

738

Is the signedness param ever non-signless?

[mehdi_amini]

mlir/lib/IR/BuiltinAttributes.cpp

738

Not yet: but we know where this is going :)

[Mogball]

use RankedTensorType in the AttrDef

mlir/include/mlir/IR/BuiltinAttributes.h

public:
 
   /// 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);
+  static Attribute parse(AsmParser &parser, Type type);
 
   /// Parse the short form `42, 100, -1` without any type prefix or braces.
-  static Attribute parseWithoutBraces(AsmParser &parser, Type odsType);
+  static Attribute parseWithoutBraces(AsmParser &parser, Type type);
 
   /// Support for isa<>/cast<>.
   static bool classof(Attribute attr);
 };
-template <>
-void DenseArrayAttr<bool>::printWithoutBraces(raw_ostream &os) const;
-template <>
-void DenseArrayAttr<int8_t>::printWithoutBraces(raw_ostream &os) const;
 
 extern template class DenseArrayAttr<bool>;
 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>;

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     ```
 
     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":$elementType,
                         Builtin_DenseArrayRawDataParameter:$rawData);
   let extraClassDeclaration = [{
-    // All possible supported element type.
-    enum class EltType { I1, 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<bool, int8_t, int16_t, int32_t, int64_t, float, double>;

mlir/lib/IR/BuiltinAttributes.cpp

 #include "mlir/IR/DialectResourceBlobManager.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 "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Sequence.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Endian.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 /// Tablegen Attribute Definitions
 //===----------------------------------------------------------------------===//
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::I1:
-    this->cast<DenseBoolArrayAttr>().printWithoutBraces(os);
-    return;
-  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>");
+  llvm::TypeSwitch<DenseArrayBaseAttr>(*this)
+      .Case<DenseBoolArrayAttr, DenseI8ArrayAttr, DenseI16ArrayAttr,
+            DenseI32ArrayAttr, DenseI64ArrayAttr, DenseF32ArrayAttr,
+            DenseF64ArrayAttr>([&](auto attr) { attr.printWithoutBraces(os); });
 }
 
 void DenseArrayBaseAttr::print(raw_ostream &os) const {
   os << "[";
   printWithoutBraces(os);
   os << "]";
 }
 
-template <typename T>
-void DenseArrayAttr<T>::print(AsmPrinter &printer) const {
-  print(printer.getStream());
+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>();
+    if (!type || type.getWidth() != width)
+      return false;
+    return type.getSignedness() == signedness;
   }
 
-template <typename T>
-void DenseArrayAttr<T>::printWithoutBraces(raw_ostream &os) const {
-  llvm::interleaveComma(asArrayRef(), os);
+  static Type getElementType(MLIRContext *ctx) {
+    return IntegerType::get(ctx, width, signedness);
   }
 
-/// Specialization for bool to print `true` or `false`.
-template <>
-void DenseArrayAttr<bool>::printWithoutBraces(raw_ostream &os) const {
-  llvm::interleaveComma(asArrayRef(), os,
-                        [&](bool v) { os << (v ? "true" : "false"); });
+  template <typename T>
+  static void printElement(raw_ostream &os, T value) {
+    os << value;
   }
 
-/// Specialization for int8_t for forcing printing as number instead of chars.
-template <>
-void DenseArrayAttr<int8_t>::printWithoutBraces(raw_ostream &os) const {
-  llvm::interleaveComma(asArrayRef(), os, [&](int64_t v) { os << v; });
+  template <typename T>
+  static ParseResult parseElement(AsmParser &parser, T &value) {
+    return parser.parseInteger(value);
   }
-
+};
 template <typename T>
-void DenseArrayAttr<T>::print(raw_ostream &os) const {
-  os << "[";
-  printWithoutBraces(os);
-  os << "]";
+struct DenseArrayAttrUtil;
+
+/// Specialization for boolean elements to print 'true' and 'false' literals for
+/// elements.
+template <>
+struct DenseArrayAttrUtil<bool> : public DenseArrayAttrIntUtil<1> {
+  static void printElement(raw_ostream &os, bool value) {
+    os << (value ? "true" : "false");
   }
+};
 
-/// Parse a single element: generic template for int types, specialized for
-/// floating point and boolean values below.
-template <typename T>
-static ParseResult parseDenseArrayAttrElt(AsmParser &parser, T &value) {
-  return parser.parseInteger(value);
+/// Specialization for 8-bit integers to ensure values are printed as integers
+/// and not characters.
+template <>
+struct DenseArrayAttrUtil<int8_t> : public DenseArrayAttrIntUtil<8> {
+  static void printElement(raw_ostream &os, int8_t value) {
+    os << static_cast<int>(value);
   }
+};
+template <>
+struct DenseArrayAttrUtil<int16_t> : public DenseArrayAttrIntUtil<16> {};
+template <>
+struct DenseArrayAttrUtil<int32_t> : public DenseArrayAttrIntUtil<32> {};
+template <>
+struct DenseArrayAttrUtil<int64_t> : public DenseArrayAttrIntUtil<64> {};
 
+/// Specialization for 32-bit floats.
 template <>
-ParseResult parseDenseArrayAttrElt<float>(AsmParser &parser, float &value) {
+struct DenseArrayAttrUtil<float> {
+  static bool checkElementType(Type eltType) { return eltType.isF32(); }
+  static Type getElementType(MLIRContext *ctx) { return Float32Type::get(ctx); }
+  static void printElement(raw_ostream &os, float value) { os << value; }
+
+  /// Parse a double and cast it to a float.
+  static ParseResult parseElement(AsmParser &parser, float &value) {
     double doubleVal;
     if (parser.parseFloat(doubleVal))
       return failure();
     value = doubleVal;
     return success();
   }
+};
 
+/// Specialization for 64-bit floats.
 template <>
-ParseResult parseDenseArrayAttrElt<double>(AsmParser &parser, double &value) {
+struct DenseArrayAttrUtil<double> {
+  static bool checkElementType(Type eltType) { return eltType.isF64(); }
+  static Type getElementType(MLIRContext *ctx) { return Float64Type::get(ctx); }
+  static void printElement(raw_ostream &os, float value) { os << value; }
+  static ParseResult parseElement(AsmParser &parser, double &value) {
     return parser.parseFloat(value);
   }
+};
+} // namespace
+
+template <typename T>
+void DenseArrayAttr<T>::print(AsmPrinter &printer) const {
+  print(printer.getStream());
+}
+
+template <typename T>
+void DenseArrayAttr<T>::printWithoutBraces(raw_ostream &os) const {
+  llvm::interleaveComma(asArrayRef(), os, [&](T value) {
+    DenseArrayAttrUtil<T>::printElement(os, value);
+  });
+}
+
+template <typename T>
+void DenseArrayAttr<T>::print(raw_ostream &os) const {
+  os << "[";
+  printWithoutBraces(os);
+  os << "]";
+}
 
 /// 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))
+        if (DenseArrayAttrUtil<T>::parseElement(parser, value))
           return failure();
         data.push_back(value);
         return success();
       })))
     return {};
   return get(parser.getContext(), data);
 }
 

 template <typename T>
 DenseArrayAttr<T>::operator ArrayRef<T>() const {
   ArrayRef<char> raw = getRawData();
   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<bool> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I1;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, IntegerType::get(context, 1));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<int8_t> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I8;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, IntegerType::get(context, 8));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<int16_t> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I16;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, IntegerType::get(context, 16));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<int32_t> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I32;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, IntegerType::get(context, 32));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<int64_t> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::I64;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, IntegerType::get(context, 64));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<float> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::F32;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::get(shape, Float32Type::get(context));
-  }
-};
-template <>
-struct denseArrayAttrEltTypeBuilder<double> {
-  constexpr static auto eltType = DenseArrayBaseAttr::EltType::F64;
-  static ShapedType getShapedType(MLIRContext *context,
-                                  ArrayRef<int64_t> shape) {
-    return RankedTensorType::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 size = static_cast<int64_t>(content.size());
-  auto shapedType =
-      denseArrayAttrEltTypeBuilder<T>::getShapedType(context, size);
-  auto eltType = denseArrayAttrEltTypeBuilder<T>::eltType;
+  auto shapedType = RankedTensorType::get(
+      content.size(), DenseArrayAttrUtil<T>::getElementType(context));
   auto rawArray = ArrayRef<char>(reinterpret_cast<const char *>(content.data()),
                                  content.size() * sizeof(T));
-  return Base::get(context, shapedType, eltType, rawArray)
+  return Base::get(context, shapedType, 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;
+  if (auto denseArray = attr.dyn_cast<DenseArrayBaseAttr>())
+    return DenseArrayAttrUtil<T>::checkElementType(denseArray.getElementType());
+  return false;
 }
 
 namespace mlir {
 namespace detail {
 // Explicit instantiation for all the supported DenseArrayAttr.
 template class DenseArrayAttr<bool>;
 template class DenseArrayAttr<int8_t>;
 template class DenseArrayAttr<int16_t>;

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/ADT/TypeSwitch.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>
struct TestElementsAttrInterface
   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::I1:
-            testElementsAttrIteration<bool>(op, elementsAttr, "bool");
-            break;
-          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;
-          }
+          llvm::TypeSwitch<DenseArrayBaseAttr>(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");
+              });
           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");
       }
     });