diff --git a/mlir/include/mlir/IR/BuiltinAttributes.td b/mlir/include/mlir/IR/BuiltinAttributes.td
--- a/mlir/include/mlir/IR/BuiltinAttributes.td
+++ b/mlir/include/mlir/IR/BuiltinAttributes.td
@@ -155,8 +155,11 @@
   }];
 }
 
-def Builtin_DenseArray : Builtin_Attr<
-    "DenseArray", [ElementsAttrInterface, TypedAttrInterface]> {
+def Builtin_DenseArray : Builtin_Attr<"DenseArray", [
+    DeclareAttrInterfaceMethods<ElementsAttrInterface,
+                                ["getValuesImpl", "isSplat"]>,
+    TypedAttrInterface
+  ]> {
   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
@@ -206,24 +209,6 @@
     }]>,
   ];
 
-  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>;
-    const bool *value_begin_impl(OverloadToken<bool>) const;
-    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;
-  }];
-
   let genVerifyDecl = 1;
 }
 
diff --git a/mlir/lib/IR/BuiltinAttributes.cpp b/mlir/lib/IR/BuiltinAttributes.cpp
--- a/mlir/lib/IR/BuiltinAttributes.cpp
+++ b/mlir/lib/IR/BuiltinAttributes.cpp
@@ -709,28 +709,46 @@
   return success();
 }
 
-const bool *DenseArrayAttr::value_begin_impl(OverloadToken<bool>) const {
-  return cast<DenseBoolArrayAttr>().asArrayRef().begin();
-}
-const int8_t *DenseArrayAttr::value_begin_impl(OverloadToken<int8_t>) const {
-  return cast<DenseI8ArrayAttr>().asArrayRef().begin();
-}
-const int16_t *DenseArrayAttr::value_begin_impl(OverloadToken<int16_t>) const {
-  return cast<DenseI16ArrayAttr>().asArrayRef().begin();
-}
-const int32_t *DenseArrayAttr::value_begin_impl(OverloadToken<int32_t>) const {
-  return cast<DenseI32ArrayAttr>().asArrayRef().begin();
-}
-const int64_t *DenseArrayAttr::value_begin_impl(OverloadToken<int64_t>) const {
-  return cast<DenseI64ArrayAttr>().asArrayRef().begin();
-}
-const float *DenseArrayAttr::value_begin_impl(OverloadToken<float>) const {
-  return cast<DenseF32ArrayAttr>().asArrayRef().begin();
-}
-const double *DenseArrayAttr::value_begin_impl(OverloadToken<double>) const {
-  return cast<DenseF64ArrayAttr>().asArrayRef().begin();
+//===----------------------------------------------------------------------===//
+// ElementsAttr Implementation
+
+/// A dense array is never a splat.
+bool DenseArrayAttr::isSplat() const { return false; }
+
+/// Try to dispatch to the given dense array subclass to contiguously iterate
+/// its elements.
+template <typename DenseArrayT>
+static FailureOr<detail::ElementsAttrIndexer>
+tryContainerBegin(DenseArrayAttr attr) {
+  if (auto container = attr.dyn_cast<DenseArrayT>())
+    return detail::ElementsAttrIndexer::contiguous(
+        /*isSplat=*/false, container.asArrayRef().begin());
+  return failure();
+}
+
+/// Re-implement `getValuesImpl` to dynamically dispatch to subclasses.
+FailureOr<detail::ElementsAttrIndexer>
+DenseArrayAttr::getValuesImpl(TypeID elementID) const {
+  if (elementID == TypeID::get<bool>())
+    return tryContainerBegin<DenseBoolArrayAttr>(*this);
+  if (elementID == TypeID::get<int8_t>())
+    return tryContainerBegin<DenseI8ArrayAttr>(*this);
+  if (elementID == TypeID::get<int16_t>())
+    return tryContainerBegin<DenseI16ArrayAttr>(*this);
+  if (elementID == TypeID::get<int32_t>())
+    return tryContainerBegin<DenseI32ArrayAttr>(*this);
+  if (elementID == TypeID::get<int64_t>())
+    return tryContainerBegin<DenseI64ArrayAttr>(*this);
+  if (elementID == TypeID::get<float>())
+    return tryContainerBegin<DenseF32ArrayAttr>(*this);
+  if (elementID == TypeID::get<double>())
+    return tryContainerBegin<DenseF64ArrayAttr>(*this);
+  return failure();
 }
 
+//===----------------------------------------------------------------------===//
+// DenseArrayAttrUtil
+
 namespace {
 /// Instantiations of this class provide utilities for interacting with native
 /// data types in the context of DenseArrayAttr.
@@ -814,6 +832,9 @@
 };
 } // namespace
 
+//===----------------------------------------------------------------------===//
+// DenseArrayAttrImpl
+
 template <typename T>
 void DenseArrayAttrImpl<T>::print(AsmPrinter &printer) const {
   print(printer.getStream());