[mlir][IR] Move the remaining builtin attributes to ODS.

[rriddle]

Summary

With this revision, all builtin attributes and types will have been moved to the ODS generator.

Depends On D98473

[mehdi_amini]

This change broke the mlir-nvidia bot, you didn't get an email notification for this?

It seems that the issue is with the Python bindings which are exercising recovering from a getChecked() test.

The test does:

try:
  fattr_invalid = FloatAttr.get(
      IntegerType.get_signless(32), 42)
except ValueError as e:
  # CHECK: invalid 'Type(i32)' and expected floating point type.
  print(e)

But now it asserts:

mlir/include/mlir/IR/Types.h:243: U mlir::Type::cast() const [U = mlir::FloatType]: Assertion `isa<U>()' failed.
Aborted

I think this is what is fixed in https://reviews.llvm.org/D98764 ; but I'm curious why it was broken in this patch and if there are other "demon" hidden in here?

mlir/include/mlir/IR/BuiltinAttributes.h

 
 #include "mlir/IR/Attributes.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Sequence.h"
 #include <complex>
 
 namespace mlir {
 class AffineMap;
+class BoolAttr;
+class DenseIntElementsAttr;
 class FlatSymbolRefAttr;
 class FunctionType;
 class IntegerSet;
+class IntegerType;
 class Location;
 class ShapedType;
-} // namespace mlir
-
-//===----------------------------------------------------------------------===//
-// Tablegen Attribute Declarations
-//===----------------------------------------------------------------------===//
-
-#define GET_ATTRDEF_CLASSES
-#include "mlir/IR/BuiltinAttributes.h.inc"
-
-//===----------------------------------------------------------------------===//
-// C++ Attribute Declarations
-//===----------------------------------------------------------------------===//
-
-namespace mlir {
-namespace detail {
-
-struct IntegerAttributeStorage;
-struct FloatAttributeStorage;
-struct SymbolRefAttributeStorage;
-struct TypeAttributeStorage;
-
-/// Elements Attributes.
-struct DenseIntOrFPElementsAttributeStorage;
-struct DenseStringElementsAttributeStorage;
-struct OpaqueElementsAttributeStorage;
-struct SparseElementsAttributeStorage;
-} // namespace detail
-
-//===----------------------------------------------------------------------===//
-// FloatAttr
-//===----------------------------------------------------------------------===//
-
-class FloatAttr : public Attribute::AttrBase<FloatAttr, Attribute,
-                                             detail::FloatAttributeStorage> {
-public:
-  using Base::Base;
-  using Base::getChecked;
-  using ValueType = APFloat;
-
-  /// Return a float attribute for the specified value in the specified type.
-  /// These methods should only be used for simple constant values, e.g 1.0/2.0,
-  /// that are known-valid both as host double and the 'type' format.
-  static FloatAttr get(Type type, double value);
-  static FloatAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, double value);
-
-  /// Return a float attribute for the specified value in the specified type.
-  static FloatAttr get(Type type, const APFloat &value);
-  static FloatAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, const APFloat &value);
-
-  APFloat getValue() const;
-
-  /// This function is used to convert the value to a double, even if it loses
-  /// precision.
-  double getValueAsDouble() const;
-  static double getValueAsDouble(APFloat val);
-
-  /// Verify the construction invariants for a double value.
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, double value);
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, const APFloat &value);
-};
-
-//===----------------------------------------------------------------------===//
-// IntegerAttr
-//===----------------------------------------------------------------------===//
-
-class IntegerAttr
-    : public Attribute::AttrBase<IntegerAttr, Attribute,
-                                 detail::IntegerAttributeStorage> {
-public:
-  using Base::Base;
-  using ValueType = APInt;
-
-  static IntegerAttr get(Type type, int64_t value);
-  static IntegerAttr get(Type type, const APInt &value);
-
-  APInt getValue() const;
-  /// Return the integer value as a 64-bit int. The attribute must be a signless
-  /// integer.
-  // TODO: Change callers to use getValue instead.
-  int64_t getInt() const;
-  /// Return the integer value as a signed 64-bit int. The attribute must be
-  /// a signed integer.
-  int64_t getSInt() const;
-  /// Return the integer value as a unsigned 64-bit int. The attribute must be
-  /// an unsigned integer.
-  uint64_t getUInt() const;
-
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, int64_t value);
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type type, const APInt &value);
-};
-
-//===----------------------------------------------------------------------===//
-// BoolAttr
-
-/// Special case of IntegerAttr to represent boolean integers, i.e., signless i1
-/// integers.
-class BoolAttr : public Attribute {
-public:
-  using Attribute::Attribute;
-  using ValueType = bool;
-
-  static BoolAttr get(MLIRContext *context, bool value);
-
-  /// Enable conversion to IntegerAttr. This uses conversion vs. inheritance to
-  /// avoid bringing in all of IntegerAttrs methods.
-  operator IntegerAttr() const { return IntegerAttr(impl); }
-
-  /// Return the boolean value of this attribute.
-  bool getValue() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(Attribute attr);
-};
-
-//===----------------------------------------------------------------------===//
-// FlatSymbolRefAttr
-//===----------------------------------------------------------------------===//
-
-/// A symbol reference with a reference path containing a single element. This
-/// is used to refer to an operation within the current symbol table.
-class FlatSymbolRefAttr : public SymbolRefAttr {
-public:
-  using SymbolRefAttr::SymbolRefAttr;
-  using ValueType = StringRef;
-
-  /// Construct a symbol reference for the given value name.
-  static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value) {
-    return SymbolRefAttr::get(ctx, value);
-  }
-
-  /// Returns the name of the held symbol reference.
-  StringRef getValue() const { return getRootReference(); }
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(Attribute attr) {
-    SymbolRefAttr refAttr = attr.dyn_cast<SymbolRefAttr>();
-    return refAttr && refAttr.getNestedReferences().empty();
-  }
-
-private:
-  using SymbolRefAttr::get;
-  using SymbolRefAttr::getNestedReferences;
-};
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 template <typename T> class ElementsAttrIterator;
 template <typename T> class ElementsAttrRange;
protected:
   bool isValidIntOrFloat(int64_t dataEltSize, bool isInt, bool isSigned) const;
 
   /// Check the information for a C++ data type, check if this type is valid for
   /// the current attribute. This method is used to verify specific type
   /// invariants that the templatized 'getValues' method cannot.
   bool isValidComplex(int64_t dataEltSize, bool isInt, bool isSigned) const;
 };
 
-/// An attribute class for representing dense arrays of strings. The structure
-/// storing and querying a list of densely packed strings.
-class DenseStringElementsAttr
-    : public Attribute::AttrBase<DenseStringElementsAttr, DenseElementsAttr,
-                                 detail::DenseStringElementsAttributeStorage> {
-
+/// An attribute that represents a reference to a splat vector or tensor
+/// constant, meaning all of the elements have the same value.
+class SplatElementsAttr : public DenseElementsAttr {
 public:
-  using Base::Base;
-
-  /// Overload of the raw 'get' method that asserts that the given type is of
-  /// integer or floating-point type. This method is used to verify type
-  /// invariants that the templatized 'get' method cannot.
-  static DenseStringElementsAttr get(ShapedType type, ArrayRef<StringRef> data);
+  using DenseElementsAttr::DenseElementsAttr;
 
-protected:
-  friend DenseElementsAttr;
+  /// Method for support type inquiry through isa, cast and dyn_cast.
+  static bool classof(Attribute attr) {
+    auto denseAttr = attr.dyn_cast<DenseElementsAttr>();
+    return denseAttr && denseAttr.isSplat();
+  }
 };
 
-/// An attribute class for specializing behavior of Int and Floating-point
-/// densely packed string arrays.
-class DenseIntOrFPElementsAttr
-    : public Attribute::AttrBase<DenseIntOrFPElementsAttr, DenseElementsAttr,
-                                 detail::DenseIntOrFPElementsAttributeStorage> {
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Tablegen Attribute Declarations
+//===----------------------------------------------------------------------===//
+
+#define GET_ATTRDEF_CLASSES
+#include "mlir/IR/BuiltinAttributes.h.inc"
+
+//===----------------------------------------------------------------------===//
+// C++ Attribute Declarations
+//===----------------------------------------------------------------------===//
 
+namespace mlir {
+//===----------------------------------------------------------------------===//
+// BoolAttr
+//===----------------------------------------------------------------------===//
+
+/// Special case of IntegerAttr to represent boolean integers, i.e., signless i1
+/// integers.
+class BoolAttr : public Attribute {
 public:
-  using Base::Base;
+  using Attribute::Attribute;
+  using ValueType = bool;
 
-  /// Convert endianess of input ArrayRef for big-endian(BE) machines. All of
-  /// the elements of `inRawData` has `type`. If `inRawData` is little endian
-  /// (LE), it is converted to big endian (BE). Conversely, if `inRawData` is
-  /// BE, converted to LE.
-  static void
-  convertEndianOfArrayRefForBEmachine(ArrayRef<char> inRawData,
-                                      MutableArrayRef<char> outRawData,
-                                      ShapedType type);
-
-  /// Convert endianess of input for big-endian(BE) machines. The number of
-  /// elements of `inRawData` is `numElements`, and each element has
-  /// `elementBitWidth` bits. If `inRawData` is little endian (LE), it is
-  /// converted to big endian (BE) and saved in `outRawData`. Conversely, if
-  /// `inRawData` is BE, converted to LE.
-  static void convertEndianOfCharForBEmachine(const char *inRawData,
-                                              char *outRawData,
-                                              size_t elementBitWidth,
-                                              size_t numElements);
+  static BoolAttr get(MLIRContext *context, bool value);
 
-protected:
-  friend DenseElementsAttr;
+  /// Enable conversion to IntegerAttr. This uses conversion vs. inheritance to
+  /// avoid bringing in all of IntegerAttrs methods.
+  operator IntegerAttr() const { return IntegerAttr(impl); }
 
-  /// Constructs a dense elements attribute from an array of raw APFloat values.
-  /// Each APFloat value is expected to have the same bitwidth as the element
-  /// type of 'type'. 'type' must be a vector or tensor with static shape.
-  static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
-                                  ArrayRef<APFloat> values, bool isSplat);
+  /// Return the boolean value of this attribute.
+  bool getValue() const;
 
-  /// Constructs a dense elements attribute from an array of raw APInt values.
-  /// Each APInt value is expected to have the same bitwidth as the element type
-  /// of 'type'. 'type' must be a vector or tensor with static shape.
-  static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
-                                  ArrayRef<APInt> values, bool isSplat);
+  /// Methods for support type inquiry through isa, cast, and dyn_cast.
+  static bool classof(Attribute attr);
+};
 
-  /// Get or create a new dense elements attribute instance with the given raw
-  /// data buffer. 'type' must be a vector or tensor with static shape.
-  static DenseElementsAttr getRaw(ShapedType type, ArrayRef<char> data,
-                                  bool isSplat);
+//===----------------------------------------------------------------------===//
+// FlatSymbolRefAttr
+//===----------------------------------------------------------------------===//
 
-  /// Overload of the raw 'get' method that asserts that the given type is of
-  /// complex type. This method is used to verify type invariants that the
-  /// templatized 'get' method cannot.
-  static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
-                                         int64_t dataEltSize, bool isInt,
-                                         bool isSigned);
+/// A symbol reference with a reference path containing a single element. This
+/// is used to refer to an operation within the current symbol table.
+class FlatSymbolRefAttr : public SymbolRefAttr {
+public:
+  using SymbolRefAttr::SymbolRefAttr;
+  using ValueType = StringRef;
 
-  /// Overload of the raw 'get' method that asserts that the given type is of
-  /// integer or floating-point type. This method is used to verify type
-  /// invariants that the templatized 'get' method cannot.
-  static DenseElementsAttr getRawIntOrFloat(ShapedType type,
-                                            ArrayRef<char> data,
-                                            int64_t dataEltSize, bool isInt,
-                                            bool isSigned);
+  /// Construct a symbol reference for the given value name.
+  static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value) {
+    return SymbolRefAttr::get(ctx, value);
+  }
+
+  /// Returns the name of the held symbol reference.
+  StringRef getValue() const { return getRootReference(); }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast.
+  static bool classof(Attribute attr) {
+    SymbolRefAttr refAttr = attr.dyn_cast<SymbolRefAttr>();
+    return refAttr && refAttr.getNestedReferences().empty();
+  }
+
+private:
+  using SymbolRefAttr::get;
+  using SymbolRefAttr::getNestedReferences;
 };
 
+//===----------------------------------------------------------------------===//
+// DenseFPElementsAttr
+//===----------------------------------------------------------------------===//
+
 /// An attribute that represents a reference to a dense float vector or tensor
 /// object. Each element is stored as a double.
 class DenseFPElementsAttr : public DenseIntOrFPElementsAttr {
 public:
   using iterator = DenseElementsAttr::FloatElementIterator;
 
   using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
public:
   /// Iterator access to the float element values.
   iterator begin() const { return float_value_begin(); }
   iterator end() const { return float_value_end(); }
 
   /// Method for supporting type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
 };
 
+//===----------------------------------------------------------------------===//
+// DenseIntElementsAttr
+//===----------------------------------------------------------------------===//
+
 /// An attribute that represents a reference to a dense integer vector or tensor
 /// object.
 class DenseIntElementsAttr : public DenseIntOrFPElementsAttr {
 public:
   /// DenseIntElementsAttr iterates on APInt, so we can use the raw element
   /// iterator directly.
   using iterator = DenseElementsAttr::IntElementIterator;
 
public:
   /// Iterator access to the integer element values.
   iterator begin() const { return raw_int_begin(); }
   iterator end() const { return raw_int_end(); }
 
   /// Method for supporting type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
 };
 
-/// An opaque attribute that represents a reference to a vector or tensor
-/// constant with opaque content. This representation is for tensor constants
-/// which the compiler may not need to interpret. This attribute is always
-/// associated with a particular dialect, which provides a method to convert
-/// tensor representation to a non-opaque format.
-class OpaqueElementsAttr
-    : public Attribute::AttrBase<OpaqueElementsAttr, ElementsAttr,
-                                 detail::OpaqueElementsAttributeStorage> {
-public:
-  using Base::Base;
-  using ValueType = StringRef;
-
-  static OpaqueElementsAttr get(Dialect *dialect, ShapedType type,
-                                StringRef bytes);
-
-  StringRef getValue() const;
-
-  /// Return the value at the given index. The 'index' is expected to refer to a
-  /// valid element.
-  Attribute getValue(ArrayRef<uint64_t> index) const;
-
-  /// Decodes the attribute value using dialect-specific decoding hook.
-  /// Returns false if decoding is successful. If not, returns true and leaves
-  /// 'result' argument unspecified.
-  bool decode(ElementsAttr &result);
-
-  /// Returns dialect associated with this opaque constant.
-  Dialect *getDialect() const;
-};
-
-/// An attribute that represents a reference to a sparse vector or tensor
-/// object.
-///
-/// This class uses COO (coordinate list) encoding to represent the sparse
-/// elements in an element attribute. Specifically, the sparse vector/tensor
-/// stores the indices and values as two separate dense elements attributes of
-/// tensor type (even if the sparse attribute is of vector type, in order to
-/// support empty lists). The dense elements attribute indices is a 2-D tensor
-/// of 64-bit integer elements with shape [N, ndims], which specifies the
-/// indices of the elements in the sparse tensor that contains nonzero values.
-/// The dense elements attribute values is a 1-D tensor with shape [N], and it
-/// supplies the corresponding values for the indices.
-///
-/// For example,
-/// `sparse<tensor<3x4xi32>, [[0, 0], [1, 2]], [1, 5]>` represents tensor
-/// [[1, 0, 0, 0],
-///  [0, 0, 5, 0],
-///  [0, 0, 0, 0]].
-class SparseElementsAttr
-    : public Attribute::AttrBase<SparseElementsAttr, ElementsAttr,
-                                 detail::SparseElementsAttributeStorage> {
-public:
-  using Base::Base;
+//===----------------------------------------------------------------------===//
+// SparseElementsAttr
+//===----------------------------------------------------------------------===//
 
-  template <typename T>
-  using iterator =
-      llvm::mapped_iterator<llvm::detail::value_sequence_iterator<ptrdiff_t>,
-                            std::function<T(ptrdiff_t)>>;
-
-  /// 'type' must be a vector or tensor with static shape.
-  static SparseElementsAttr get(ShapedType type, DenseElementsAttr indices,
-                                DenseElementsAttr values);
-
-  DenseIntElementsAttr getIndices() const;
-
-  DenseElementsAttr getValues() const;
-
-  /// Return the values of this attribute in the form of the given type 'T'. 'T'
-  /// may be any of Attribute, APInt, APFloat, c++ integer/float types, etc.
-  template <typename T> llvm::iterator_range<iterator<T>> getValues() const {
-    auto zeroValue = getZeroValue<T>();
-    auto valueIt = getValues().getValues<T>().begin();
-    const std::vector<ptrdiff_t> flatSparseIndices(getFlattenedSparseIndices());
-    // TODO: Move-capture flatSparseIndices when c++14 is available.
-    std::function<T(ptrdiff_t)> mapFn = [=](ptrdiff_t index) {
-      // Try to map the current index to one of the sparse indices.
-      for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)
-        if (flatSparseIndices[i] == index)
-          return *std::next(valueIt, i);
-      // Otherwise, return the zero value.
-      return zeroValue;
-    };
-    return llvm::map_range(llvm::seq<ptrdiff_t>(0, getNumElements()), mapFn);
-  }
+auto SparseElementsAttr::getValues() const
+    -> llvm::iterator_range<iterator<T>> {
 
-  /// Return the value of the element at the given index. The 'index' is
-  /// expected to refer to a valid element.
-  Attribute getValue(ArrayRef<uint64_t> index) const;
-
-private:
-  /// Get a zero APFloat for the given sparse attribute.
-  APFloat getZeroAPFloat() const;
-
-  /// Get a zero APInt for the given sparse attribute.
-  APInt getZeroAPInt() const;
-
-  /// Get a zero attribute for the given sparse attribute.
-  Attribute getZeroAttr() const;
-
-  /// Utility methods to generate a zero value of some type 'T'. This is used by
-  /// the 'iterator' class.
-  /// Get a zero for a given attribute type.
-  template <typename T>
-  typename std::enable_if<std::is_base_of<Attribute, T>::value, T>::type
-  getZeroValue() const {
-    return getZeroAttr().template cast<T>();
-  }
-  /// Get a zero for an APInt.
-  template <typename T>
-  typename std::enable_if<std::is_same<APInt, T>::value, T>::type
-  getZeroValue() const {
-    return getZeroAPInt();
-  }
-  template <typename T>
-  typename std::enable_if<std::is_same<std::complex<APInt>, T>::value, T>::type
-  getZeroValue() const {
-    APInt intZero = getZeroAPInt();
-    return {intZero, intZero};
-  }
-  /// Get a zero for an APFloat.
-  template <typename T>
-  typename std::enable_if<std::is_same<APFloat, T>::value, T>::type
-  getZeroValue() const {
-    return getZeroAPFloat();
-  }
-  template <typename T>
-  typename std::enable_if<std::is_same<std::complex<APFloat>, T>::value,
-                          T>::type
-  getZeroValue() const {
-    APFloat floatZero = getZeroAPFloat();
-    return {floatZero, floatZero};
-  }
-
-  /// Get a zero for an C++ integer, float, StringRef, or complex type.
-  template <typename T>
-  typename std::enable_if<
-      std::numeric_limits<T>::is_integer ||
-          DenseElementsAttr::is_valid_cpp_fp_type<T>::value ||
-          std::is_same<T, StringRef>::value ||
-          (detail::is_complex_t<T>::value &&
-           !llvm::is_one_of<T, std::complex<APInt>,
-                            std::complex<APFloat>>::value),
-      T>::type
-  getZeroValue() const {
-    return T();
-  }
-
-  /// Flatten, and return, all of the sparse indices in this attribute in
-  /// row-major order.
-  std::vector<ptrdiff_t> getFlattenedSparseIndices() const;
-};
-
-/// An attribute that represents a reference to a splat vector or tensor
-/// constant, meaning all of the elements have the same value.
-class SplatElementsAttr : public DenseElementsAttr {
-public:
-  using DenseElementsAttr::DenseElementsAttr;
-
-  /// Method for support type inquiry through isa, cast and dyn_cast.
-  static bool classof(Attribute attr) {
-    auto denseAttr = attr.dyn_cast<DenseElementsAttr>();
-    return denseAttr && denseAttr.isSplat();
-  }
-};
-
 namespace detail {
 /// This class represents a general iterator over the values of an ElementsAttr.
 /// It supports all subclasses aside from OpaqueElementsAttr.
 template <typename T>
 class ElementsAttrIterator
     : public llvm::iterator_facade_base<ElementsAttrIterator<T>,
                                         std::random_access_iterator_tag, T,
                                         std::ptrdiff_t, T, T> {

mlir/include/mlir/IR/BuiltinAttributes.td

 include "mlir/IR/BuiltinDialect.td"
 
 // TODO: Currently the attributes defined in this file are prefixed with
 // `Builtin_`.  This is to differentiate the attributes here with the ones in
 // OpBase.td. We should remove the definitions in OpBase.td, and repoint users
 // to this file instead.
 
 // Base class for Builtin dialect attributes.
-class Builtin_Attr<string name> : AttrDef<Builtin_Dialect, name> {
+class Builtin_Attr<string name, string baseCppClass = "::mlir::Attribute">
+    : AttrDef<Builtin_Dialect, name, baseCppClass> {
   let mnemonic = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // AffineMapAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_AffineMapAttr : Builtin_Attr<"AffineMap"> {
auto getAsValueRange() {
       return llvm::map_range(getAsRange<AttrTy>(), [](AttrTy attr) {
         return static_cast<UnderlyingTy>(attr.getValue());
       });
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// DenseIntOrFPElementsAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_DenseIntOrFPElementsAttr
+    : Builtin_Attr<"DenseIntOrFPElements", "DenseElementsAttr"> {
+  let summary = "An Attribute containing a dense multi-dimensional array of "
+                "integer or floating-point values";
+  let description = [{
+    Syntax:
+
+    ```
+    dense-intorfloat-elements-attribute ::= `dense` `<` attribute-value `>` `:`
+                                            ( tensor-type | vector-type )
+    ```
+
+    A dense int-or-float elements attribute is an elements attribute containing
+    a densely packed vector or tensor of integer or floating-point values. The
+    element type of this attribute is required to be either an `IntegerType` or
+    a `FloatType`.
+
+    Examples:
+
+    ```
+    // A splat tensor of integer values.
+    dense<10> : tensor<2xi32>
+    // A tensor of 2 float32 elements.
+    dense<[10.0, 11.0]> : tensor<2xf32>
+    ```
+  }];
+  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
+                        "ArrayRef<char>":$rawData);
+  let extraClassDeclaration = [{
+    /// Convert endianess of input ArrayRef for big-endian(BE) machines. All of
+    /// the elements of `inRawData` has `type`. If `inRawData` is little endian
+    /// (LE), it is converted to big endian (BE). Conversely, if `inRawData` is
+    /// BE, converted to LE.
+    static void
+    convertEndianOfArrayRefForBEmachine(ArrayRef<char> inRawData,
+                                        MutableArrayRef<char> outRawData,
+                                        ShapedType type);
+
+    /// Convert endianess of input for big-endian(BE) machines. The number of
+    /// elements of `inRawData` is `numElements`, and each element has
+    /// `elementBitWidth` bits. If `inRawData` is little endian (LE), it is
+    /// converted to big endian (BE) and saved in `outRawData`. Conversely, if
+    /// `inRawData` is BE, converted to LE.
+    static void convertEndianOfCharForBEmachine(const char *inRawData,
+                                                char *outRawData,
+                                                size_t elementBitWidth,
+                                                size_t numElements);
+
+  protected:
+    friend DenseElementsAttr;
+
+    /// Constructs a dense elements attribute from an array of raw APFloat
+    /// values. Each APFloat value is expected to have the same bitwidth as the
+    /// element type of 'type'. 'type' must be a vector or tensor with static
+    /// shape.
+    static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
+                                    ArrayRef<APFloat> values, bool isSplat);
+
+    /// Constructs a dense elements attribute from an array of raw APInt values.
+    /// Each APInt value is expected to have the same bitwidth as the element
+    /// type of 'type'. 'type' must be a vector or tensor with static shape.
+    static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
+                                    ArrayRef<APInt> values, bool isSplat);
+
+    /// Get or create a new dense elements attribute instance with the given raw
+    /// data buffer. 'type' must be a vector or tensor with static shape.
+    static DenseElementsAttr getRaw(ShapedType type, ArrayRef<char> data,
+                                    bool isSplat);
+
+    /// Overload of the raw 'get' method that asserts that the given type is of
+    /// complex type. This method is used to verify type invariants that the
+    /// templatized 'get' method cannot.
+    static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
+                                           int64_t dataEltSize, bool isInt,
+                                           bool isSigned);
+
+    /// Overload of the raw 'get' method that asserts that the given type is of
+    /// integer or floating-point type. This method is used to verify type
+    /// invariants that the templatized 'get' method cannot.
+    static DenseElementsAttr getRawIntOrFloat(ShapedType type,
+                                              ArrayRef<char> data,
+                                              int64_t dataEltSize, bool isInt,
+                                              bool isSigned);
+
+  public:
+  }];
+  let genAccessors = 0;
+  let genStorageClass = 0;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// DenseStringElementsAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_DenseStringElementsAttr
+    : Builtin_Attr<"DenseStringElements", "DenseElementsAttr"> {
+  let summary = "An Attribute containing a dense multi-dimensional array of "
+                "strings";
+  let description = [{
+    Syntax:
+
+    ```
+    dense-string-elements-attribute ::= `dense` `<` attribute-value `>` `:`
+                                        ( tensor-type | vector-type )
+    ```
+
+    A dense string elements attribute is an elements attribute containing a
+    densely packed vector or tensor of string values. There are no restrictions
+    placed on the element type of this attribute, enabling the use of dialect
+    specific string types.
+
+    Examples:
+
+    ```
+    // A splat tensor of strings.
+    dense<"example"> : tensor<2x!foo.string>
+    // A tensor of 2 string elements.
+    dense<["example1", "example2"]> : tensor<2x!foo.string>
+    ```
+  }];
+  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
+                        "ArrayRef<StringRef>":$value);
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "ShapedType":$type,
+                                        "ArrayRef<StringRef>":$values), [{
+      return $_get(type.getContext(), type, values,
+                   /* isSplat */(values.size() == 1));
+    }]>,
+  ];
+  let extraClassDeclaration = [{
+  protected:
+    friend DenseElementsAttr;
+
+  public:
+  }];
+  let genAccessors = 0;
+  let genStorageClass = 0;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_DictionaryAttr : Builtin_Attr<"Dictionary"> {
   let summary = "An dictionary of named Attribute values";
   let description = [{
     Syntax:
 
private:
     friend MLIRContext;
 
   public:
   }];
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// FloatAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_FloatAttr : Builtin_Attr<"Float"> {
+  let summary = "An Attribute containing a floating-point value";
+  let description = [{
+    Syntax:
+
+    ```
+    float-attribute ::= (float-literal (`:` float-type)?)
+                      | (hexadecimal-literal `:` float-type)
+    ```
+
+    A float attribute is a literal attribute that represents a floating point
+    value of the specified [float type](#floating-point-types). It can be
+    represented in the hexadecimal form where the hexadecimal value is
+    interpreted as bits of the underlying binary representation. This form is
+    useful for representing infinity and NaN floating point values. To avoid
+    confusion with integer attributes, hexadecimal literals _must_ be followed
+    by a float type to define a float attribute.
+
+    Examples:
+
+    ```
+    42.0         // float attribute defaults to f64 type
+    42.0 : f32   // float attribute of f32 type
+    0x7C00 : f16 // positive infinity
+    0x7CFF : f16 // NaN (one of possible values)
+    42 : f32     // Error: expected integer type
+    ```
+  }];
+  let parameters = (ins AttributeSelfTypeParameter<"">:$type,
+                        APFloatParameter<"">:$value);
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "Type":$type,
+                                        "const APFloat &":$value), [{
+      return $_get(type.getContext(), type, value);
+    }]>,
+    AttrBuilderWithInferredContext<(ins "Type":$type, "double":$value), [{
+      if (type.isF64())
+        return $_get(type.getContext(), type, APFloat(value));
+
+      // This handles, e.g., F16 because there is no APFloat constructor for it.
+      bool unused;
+      APFloat val(value);
+      val.convert(type.cast<FloatType>().getFloatSemantics(),
+                  APFloat::rmNearestTiesToEven, &unused);
+      return $_get(type.getContext(), type, val);
+    }]>
+  ];
+  let extraClassDeclaration = [{
+    using ValueType = APFloat;
+
+    /// This function is used to convert the value to a double, even if it loses
+    /// precision.
+    double getValueAsDouble() const;
+    static double getValueAsDouble(APFloat val);
+  }];
+  let genVerifyDecl = 1;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// IntegerAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_IntegerAttr : Builtin_Attr<"Integer"> {
+  let summary = "An Attribute containing a integer value";
+  let description = [{
+    Syntax:
+
+    ```
+    integer-attribute ::= (integer-literal ( `:` (index-type | integer-type) )?)
+                          | `true` | `false`
+    ```
+
+    An integer attribute is a literal attribute that represents an integral
+    value of the specified integer or index type. `i1` integer attributes are
+    treated as `boolean` attributes, and use a unique assembly format of either
+    `true` or `false` depending on the value. The default type for non-boolean
+    integer attributes, if a type is not specified, is signless 64-bit integer.
+
+    Examples:
+
+    ```mlir
+    10 : i32
+    10    // : i64 is implied here.
+    true  // A bool, i.e. i1, value.
+    false // A bool, i.e. i1, value.
+    ```
+  }];
+  let parameters = (ins AttributeSelfTypeParameter<"">:$type, "APInt":$value);
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "Type":$type,
+                                        "const APInt &":$value), [{
+      if (type.isSignlessInteger(1))
+        return BoolAttr::get(type.getContext(), value.getBoolValue());
+      return $_get(type.getContext(), type, value);
+    }]>,
+    AttrBuilderWithInferredContext<(ins "Type":$type, "int64_t":$value), [{
+      // `index` has a defined internal storage width.
+      if (type.isIndex()) {
+        APInt apValue(IndexType::kInternalStorageBitWidth, value);
+        return $_get(type.getContext(), type, apValue);
+      }
+
+      IntegerType intTy = type.cast<IntegerType>();
+      APInt apValue(intTy.getWidth(), value, intTy.isSignedInteger());
+      return $_get(type.getContext(), type, apValue);
+    }]>
+  ];
+  let extraClassDeclaration = [{
+    using ValueType = APInt;
+
+    /// Return the integer value as a 64-bit int. The attribute must be a
+    /// signless integer.
+    // TODO: Change callers to use getValue instead.
+    int64_t getInt() const;
+    /// Return the integer value as a signed 64-bit int. The attribute must be
+    /// a signed integer.
+    int64_t getSInt() const;
+    /// Return the integer value as a unsigned 64-bit int. The attribute must be
+    /// an unsigned integer.
+    uint64_t getUInt() const;
+
+  private:
+    /// Return a boolean attribute. This is a special variant of the `get`
+    /// method that is used by the MLIRContext to cache the boolean IntegerAttr
+    /// instances.
+    static BoolAttr getBoolAttrUnchecked(IntegerType type, bool value);
+
+    /// Allow access to `getBoolAttrUnchecked`.
+    friend MLIRContext;
+
+  public:
+  }];
+  let genVerifyDecl = 1;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // IntegerSetAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_IntegerSetAttr : Builtin_Attr<"IntegerSet"> {
   let summary = "An Attribute containing an IntegerSet object";
   let description = [{
     Syntax:
 
let parameters = (ins "Identifier":$dialectNamespace,
                         AttributeSelfTypeParameter<"">:$type);
   let builders = [
     AttrBuilderWithInferredContext<(ins "Identifier":$dialect,
                                         "StringRef":$attrData,
                                         "Type":$type), [{
       return $_get(dialect.getContext(), dialect, attrData, type);
     }]>
   ];
-  bit genVerifyDecl = 1;
-  // let skipDefaultBuilders = 1;
+  let genVerifyDecl = 1;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// OpaqueElementsAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_OpaqueElementsAttr
+    : Builtin_Attr<"OpaqueElements", "ElementsAttr"> {
+  let summary = "An opaque representation of a multi-dimensional array";
+  let description = [{
+    Syntax:
+
+    ```
+    opaque-elements-attribute ::= `opaque` `<` dialect-namespace  `,`
+                                  hex-string-literal `>` `:`
+                                  ( tensor-type | vector-type )
+    ```
+
+    An opaque elements attribute is an elements attribute where the content of
+    the value is opaque. The representation of the constant stored by this
+    elements attribute is only understood, and thus decodable, by the dialect
+    that created it.
+
+    Note: The parsed string literal must be in hexadecimal form.
+
+    Examples:
+
+    ```mlir
+    opaque<"foo_dialect", "0xDEADBEEF"> : tensor<10xi32>
+    ```
+  }];
+
+  // TODO: Provide a way to avoid copying content of large opaque
+  // tensors This will likely require a new reference attribute kind.
+  let parameters = (ins "Identifier":$dialect,
+                        StringRefParameter<"">:$value,
+                        AttributeSelfTypeParameter<"", "ShapedType">:$type);
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "Identifier":$dialect,
+                                        "ShapedType":$type,
+                                        "StringRef":$value), [{
+      return $_get(dialect.getContext(), dialect, value, type);
+    }]>,
+    AttrBuilderWithInferredContext<(ins "Dialect *":$dialect,
+                                        "ShapedType":$type,
+                                        "StringRef":$value), [{
+      MLIRContext *ctxt = dialect->getContext();
+      Identifier dialectName = Identifier::get(dialect->getNamespace(), ctxt);
+      return $_get(ctxt, dialectName, value, type);
+    }]>
+  ];
+  let extraClassDeclaration = [{
+    using ValueType = StringRef;
+
+    /// Return the value at the given index. The 'index' is expected to refer to
+    /// a valid element.
+    Attribute getValue(ArrayRef<uint64_t> index) const;
+
+    /// Decodes the attribute value using dialect-specific decoding hook.
+    /// Returns false if decoding is successful. If not, returns true and leaves
+    /// 'result' argument unspecified.
+    bool decode(ElementsAttr &result);
+
+  }];
+  let genVerifyDecl = 1;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// SparseElementsAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_SparseElementsAttr
+    : Builtin_Attr<"SparseElements", "ElementsAttr"> {
+  let summary = "An opaque representation of a multi-dimensional array";
+  let description = [{
+    Syntax:
+
+    ```
+    sparse-elements-attribute ::= `sparse` `<` attribute-value `,`
+                                  attribute-value `>` `:`
+                                  ( tensor-type | vector-type )
+    ```
+
+    A sparse elements attribute is an elements attribute that represents a
+    sparse vector or tensor object. This is where very few of the elements are
+    non-zero.
+
+    The attribute uses COO (coordinate list) encoding to represent the sparse
+    elements of the elements attribute. The indices are stored via a 2-D tensor
+    of 64-bit integer elements with shape [N, ndims], which specifies the
+    indices of the elements in the sparse tensor that contains non-zero values.
+    The element values are stored via a 1-D tensor with shape [N], that supplies
+    the corresponding values for the indices.
+
+    Example:
+
+    ```mlir
+    sparse<[[0, 0], [1, 2]], [1, 5]> : tensor<3x4xi32>
+
+    // This represents the following tensor:
+    ///  [[1, 0, 0, 0],
+    ///   [0, 0, 5, 0],
+    ///   [0, 0, 0, 0]]
+    ```
+  }];
+
+  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
+                        "DenseIntElementsAttr":$indices,
+                        "DenseElementsAttr":$values);
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "ShapedType":$type,
+                                        "DenseElementsAttr":$indices,
+                                        "DenseElementsAttr":$values), [{
+      assert(indices.getType().getElementType().isInteger(64) &&
+             "expected sparse indices to be 64-bit integer values");
+      assert((type.isa<RankedTensorType, VectorType>()) &&
+             "type must be ranked tensor or vector");
+      assert(type.hasStaticShape() && "type must have static shape");
+      return $_get(type.getContext(), type,
+                   indices.cast<DenseIntElementsAttr>(), values);
+    }]>,
+  ];
+  let extraClassDeclaration = [{
+    template <typename T>
+    using iterator =
+        llvm::mapped_iterator<llvm::detail::value_sequence_iterator<ptrdiff_t>,
+                              std::function<T(ptrdiff_t)>>;
+
+    /// Return the values of this attribute in the form of the given type 'T'.
+    /// 'T'  may be any of Attribute, APInt, APFloat, c++ integer/float types,
+    /// etc.
+    template <typename T> llvm::iterator_range<iterator<T>> getValues() const;
+
+    /// Return the value of the element at the given index. The 'index' is
+    /// expected to refer to a valid element.
+    Attribute getValue(ArrayRef<uint64_t> index) const;
+
+  private:
+    /// Get a zero APFloat for the given sparse attribute.
+    APFloat getZeroAPFloat() const;
+
+    /// Get a zero APInt for the given sparse attribute.
+    APInt getZeroAPInt() const;
+
+    /// Get a zero attribute for the given sparse attribute.
+    Attribute getZeroAttr() const;
+
+    /// Utility methods to generate a zero value of some type 'T'. This is used
+    /// by the 'iterator' class.
+    /// Get a zero for a given attribute type.
+    template <typename T>
+    typename std::enable_if<std::is_base_of<Attribute, T>::value, T>::type
+    getZeroValue() const {
+      return getZeroAttr().template cast<T>();
+    }
+    /// Get a zero for an APInt.
+    template <typename T>
+    typename std::enable_if<std::is_same<APInt, T>::value, T>::type
+    getZeroValue() const {
+      return getZeroAPInt();
+    }
+    template <typename T>
+    typename std::enable_if<std::is_same<std::complex<APInt>, T>::value,
+                            T>::type
+    getZeroValue() const {
+      APInt intZero = getZeroAPInt();
+      return {intZero, intZero};
+    }
+    /// Get a zero for an APFloat.
+    template <typename T>
+    typename std::enable_if<std::is_same<APFloat, T>::value, T>::type
+    getZeroValue() const {
+      return getZeroAPFloat();
+    }
+    template <typename T>
+    typename std::enable_if<std::is_same<std::complex<APFloat>, T>::value,
+                            T>::type
+    getZeroValue() const {
+      APFloat floatZero = getZeroAPFloat();
+      return {floatZero, floatZero};
+    }
+
+    /// Get a zero for an C++ integer, float, StringRef, or complex type.
+    template <typename T>
+    typename std::enable_if<
+        std::numeric_limits<T>::is_integer ||
+            DenseElementsAttr::is_valid_cpp_fp_type<T>::value ||
+            std::is_same<T, StringRef>::value ||
+            (detail::is_complex_t<T>::value &&
+             !llvm::is_one_of<T, std::complex<APInt>,
+                              std::complex<APFloat>>::value),
+        T>::type
+    getZeroValue() const {
+      return T();
+    }
+
+    /// Flatten, and return, all of the sparse indices in this attribute in
+    /// row-major order.
+    std::vector<ptrdiff_t> getFlattenedSparseIndices() const;
+
+  public:
+  }];
+  let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_StringAttr : Builtin_Attr<"String"> {
   let summary = "An Attribute containing a string";

mlir/include/mlir/IR/OpBase.td

for (size_t i = 0, e = $_self.size(); i < e; ++i)
       tmpFields.push_back($_self[i].allocateInto($_allocator));
     $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
   }];
 }
 
 // This is a special parameter used for AttrDefs that represents a `mlir::Type`
 // that is also used as the value `Type` of the attribute. Only one parameter
 // of the attribute may be of this type.
-class AttributeSelfTypeParameter<string desc> :
-    AttrOrTypeParameter<"::mlir::Type", desc> {}
+class AttributeSelfTypeParameter<string desc,
+                                 string derivedType = "::mlir::Type"> :
+    AttrOrTypeParameter<derivedType, desc> {}
 
 #endif // OP_BASE

mlir/lib/IR/AsmPrinter.cpp

 //
 // We choose to use an opaque ElementsAttr literal with conspicuous content to
 // hopefully alert readers to the fact that this has been elided.
 //
 // Unfortunately, neither of the strings of an opaque ElementsAttr literal will
 // accept the string "elided". The first string must be a registered dialect
 // name and the latter must be a hex constant.
 static void printElidedElementsAttr(raw_ostream &os) {
-  os << R"(opaque<"", "0xDEADBEEF">)";
+  os << R"(opaque<"_", "0xDEADBEEF">)";
 }
 
 void ModulePrinter::printAttribute(Attribute attr,
                                    AttrTypeElision typeElision) {
   if (!attr) {
     os << "<<NULL ATTRIBUTE>>";
     return;
   }
for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";
       printSymbolReference(nestedRef.getValue(), os);
     }
 
   } else if (auto opaqueAttr = attr.dyn_cast<OpaqueElementsAttr>()) {
     if (printerFlags.shouldElideElementsAttr(opaqueAttr)) {
       printElidedElementsAttr(os);
     } else {
-      os << "opaque<\"" << opaqueAttr.getDialect()->getNamespace() << "\", ";
-      os << '"' << "0x" << llvm::toHex(opaqueAttr.getValue()) << "\">";
+      os << "opaque<\"" << opaqueAttr.getDialect() << "\", \"0x"
+         << llvm::toHex(opaqueAttr.getValue()) << "\">";
     }
 
   } else if (auto intOrFpEltAttr = attr.dyn_cast<DenseIntOrFPElementsAttr>()) {
     if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) {
       printElidedElementsAttr(os);
     } else {
       os << "dense<";
       printDenseIntOrFPElementsAttr(intOrFpEltAttr, /*allowHex=*/true);

mlir/lib/IR/AttributeDetail.h

 #include "mlir/Support/StorageUniquer.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/TrailingObjects.h"
 
 namespace mlir {
 namespace detail {
 
-/// An attribute representing a floating point value.
-struct FloatAttributeStorage final
-    : public AttributeStorage,
-      public llvm::TrailingObjects<FloatAttributeStorage, uint64_t> {
-  using KeyTy = std::pair<Type, APFloat>;
-
-  FloatAttributeStorage(const llvm::fltSemantics &semantics, Type type,
-                        size_t numObjects)
-      : AttributeStorage(type), semantics(semantics), numObjects(numObjects) {}
-
-  /// Key equality and hash functions.
-  bool operator==(const KeyTy &key) const {
-    return key.first == getType() && key.second.bitwiseIsEqual(getValue());
-  }
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_combine(key.first, llvm::hash_value(key.second));
-  }
-
-  /// Construct a key with a type and double.
-  static KeyTy getKey(Type type, double value) {
-    if (type.isF64())
-      return KeyTy(type, APFloat(value));
-
-    // This handles, e.g., F16 because there is no APFloat constructor for it.
-    bool unused;
-    APFloat val(value);
-    val.convert(type.cast<FloatType>().getFloatSemantics(),
-                APFloat::rmNearestTiesToEven, &unused);
-    return KeyTy(type, val);
-  }
-
-  /// Construct a new storage instance.
-  static FloatAttributeStorage *construct(AttributeStorageAllocator &allocator,
-                                          const KeyTy &key) {
-    const auto &apint = key.second.bitcastToAPInt();
-
-    // Here one word's bitwidth equals to that of uint64_t.
-    auto elements = ArrayRef<uint64_t>(apint.getRawData(), apint.getNumWords());
-
-    auto byteSize =
-        FloatAttributeStorage::totalSizeToAlloc<uint64_t>(elements.size());
-    auto rawMem = allocator.allocate(byteSize, alignof(FloatAttributeStorage));
-    auto result = ::new (rawMem) FloatAttributeStorage(
-        key.second.getSemantics(), key.first, elements.size());
-    std::uninitialized_copy(elements.begin(), elements.end(),
-                            result->getTrailingObjects<uint64_t>());
-    return result;
-  }
-
-  /// Returns an APFloat representing the stored value.
-  APFloat getValue() const {
-    auto val = APInt(APFloat::getSizeInBits(semantics),
-                     {getTrailingObjects<uint64_t>(), numObjects});
-    return APFloat(semantics, val);
-  }
-
-  const llvm::fltSemantics &semantics;
-  size_t numObjects;
-};
-
-/// An attribute representing an integral value.
-struct IntegerAttributeStorage final
-    : public AttributeStorage,
-      public llvm::TrailingObjects<IntegerAttributeStorage, uint64_t> {
-  using KeyTy = std::pair<Type, APInt>;
-
-  IntegerAttributeStorage(Type type, size_t numObjects)
-      : AttributeStorage(type), numObjects(numObjects) {
-    assert((type.isIndex() || type.isa<IntegerType>()) && "invalid type");
-  }
-
-  /// Key equality and hash functions.
-  bool operator==(const KeyTy &key) const {
-    return key == KeyTy(getType(), getValue());
-  }
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_combine(key.first, llvm::hash_value(key.second));
-  }
-
-  /// Construct a new storage instance.
-  static IntegerAttributeStorage *
-  construct(AttributeStorageAllocator &allocator, const KeyTy &key) {
-    Type type;
-    APInt value;
-    std::tie(type, value) = key;
-
-    auto elements = ArrayRef<uint64_t>(value.getRawData(), value.getNumWords());
-    auto size =
-        IntegerAttributeStorage::totalSizeToAlloc<uint64_t>(elements.size());
-    auto rawMem = allocator.allocate(size, alignof(IntegerAttributeStorage));
-    auto result = ::new (rawMem) IntegerAttributeStorage(type, elements.size());
-    std::uninitialized_copy(elements.begin(), elements.end(),
-                            result->getTrailingObjects<uint64_t>());
-    return result;
-  }
-
-  /// Returns an APInt representing the stored value.
-  APInt getValue() const {
-    if (getType().isIndex())
-      return APInt(64, {getTrailingObjects<uint64_t>(), numObjects});
-    return APInt(getType().getIntOrFloatBitWidth(),
-                 {getTrailingObjects<uint64_t>(), numObjects});
-  }
-
-  size_t numObjects;
-};
-
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 /// Return the bit width which DenseElementsAttr should use for this type.
 inline size_t getDenseElementBitWidth(Type eltType) {
   // Align the width for complex to 8 to make storage and interpretation easier.
   if (ComplexType comp = eltType.dyn_cast<ComplexType>())
     return llvm::alignTo<8>(getDenseElementBitWidth(comp.getElementType())) * 2;
   if (eltType.isIndex())
     return IndexType::kInternalStorageBitWidth;
   return eltType.getIntOrFloatBitWidth();
 }
 
 /// An attribute representing a reference to a dense vector or tensor object.
 struct DenseElementsAttributeStorage : public AttributeStorage {
 public:
   DenseElementsAttributeStorage(ShapedType ty, bool isSplat)
       : AttributeStorage(ty), isSplat(isSplat) {}
 
   bool isSplat;
 };
 
 /// An attribute representing a reference to a dense vector or tensor object.
-struct DenseIntOrFPElementsAttributeStorage
-    : public DenseElementsAttributeStorage {
-  DenseIntOrFPElementsAttributeStorage(ShapedType ty, ArrayRef<char> data,
-                                       bool isSplat = false)
+struct DenseIntOrFPElementsAttrStorage : public DenseElementsAttributeStorage {
+  DenseIntOrFPElementsAttrStorage(ShapedType ty, ArrayRef<char> data,
       : DenseElementsAttributeStorage(ty, isSplat), data(data) {}
 
   struct KeyTy {
     KeyTy(ShapedType type, ArrayRef<char> data, llvm::hash_code hashCode,
           bool isSplat = false)
         : type(type), data(data), hashCode(hashCode), isSplat(isSplat) {}
 
     /// The type of the dense elements.
struct DenseIntOrFPElementsAttrStorage : public DenseElementsAttributeStorage {
   }
 
   /// Hash the key for the storage.
   static llvm::hash_code hashKey(const KeyTy &key) {
     return llvm::hash_combine(key.type, key.hashCode);
   }
 
   /// Construct a new storage instance.
-  static DenseIntOrFPElementsAttributeStorage *
+  static DenseIntOrFPElementsAttrStorage *
   construct(AttributeStorageAllocator &allocator, KeyTy key) {
     // If the data buffer is non-empty, we copy it into the allocator with a
     // 64-bit alignment.
     ArrayRef<char> copy, data = key.data;
     if (!data.empty()) {
       char *rawData = reinterpret_cast<char *>(
           allocator.allocate(data.size(), alignof(uint64_t)));
       std::memcpy(rawData, data.data(), data.size());
 
       // If this is a boolean splat, make sure only the first bit is used.
       if (key.isSplat && key.type.getElementType().isInteger(1))
         rawData[0] &= 1;
       copy = ArrayRef<char>(rawData, data.size());
     }
 
-    return new (allocator.allocate<DenseIntOrFPElementsAttributeStorage>())
-        DenseIntOrFPElementsAttributeStorage(key.type, copy, key.isSplat);
+    return new (allocator.allocate<DenseIntOrFPElementsAttrStorage>())
+        DenseIntOrFPElementsAttrStorage(key.type, copy, key.isSplat);
   }
 
   ArrayRef<char> data;
 };
 
 /// An attribute representing a reference to a dense vector or tensor object
 /// containing strings.
-struct DenseStringElementsAttributeStorage
-    : public DenseElementsAttributeStorage {
-  DenseStringElementsAttributeStorage(ShapedType ty, ArrayRef<StringRef> data,
-                                      bool isSplat = false)
+struct DenseStringElementsAttrStorage : public DenseElementsAttributeStorage {
+  DenseStringElementsAttrStorage(ShapedType ty, ArrayRef<StringRef> data,
       : DenseElementsAttributeStorage(ty, isSplat), data(data) {}
 
   struct KeyTy {
     KeyTy(ShapedType type, ArrayRef<StringRef> data, llvm::hash_code hashCode,
           bool isSplat = false)
         : type(type), data(data), hashCode(hashCode), isSplat(isSplat) {}
 
     /// The type of the dense elements.
struct DenseStringElementsAttrStorage : public DenseElementsAttributeStorage {
   }
 
   /// Hash the key for the storage.
   static llvm::hash_code hashKey(const KeyTy &key) {
     return llvm::hash_combine(key.type, key.hashCode);
   }
 
   /// Construct a new storage instance.
-  static DenseStringElementsAttributeStorage *
+  static DenseStringElementsAttrStorage *
   construct(AttributeStorageAllocator &allocator, KeyTy key) {
     // If the data buffer is non-empty, we copy it into the allocator with a
     // 64-bit alignment.
     ArrayRef<StringRef> copy, data = key.data;
     if (data.empty()) {
-      return new (allocator.allocate<DenseStringElementsAttributeStorage>())
-          DenseStringElementsAttributeStorage(key.type, copy, key.isSplat);
+      return new (allocator.allocate<DenseStringElementsAttrStorage>())
+          DenseStringElementsAttrStorage(key.type, copy, key.isSplat);
     }
 
     int numEntries = key.isSplat ? 1 : data.size();
 
     // Compute the amount data needed to store the ArrayRef and StringRef
     // contents.
     size_t dataSize = sizeof(StringRef) * numEntries;
     for (int i = 0; i < numEntries; i++)
for (int i = 0; i < numEntries; i++) {
       memcpy(stringData, data[i].data(), data[i].size());
       mutableCopy[i] = StringRef(stringData, data[i].size());
       stringData += data[i].size();
     }
 
     copy =
         ArrayRef<StringRef>(reinterpret_cast<StringRef *>(rawData), numEntries);
 
-    return new (allocator.allocate<DenseStringElementsAttributeStorage>())
-        DenseStringElementsAttributeStorage(key.type, copy, key.isSplat);
+    return new (allocator.allocate<DenseStringElementsAttrStorage>())
+        DenseStringElementsAttrStorage(key.type, copy, key.isSplat);
   }
 
   ArrayRef<StringRef> data;
 };
 
-/// An attribute representing a reference to a tensor constant with opaque
-/// content.
-struct OpaqueElementsAttributeStorage : public AttributeStorage {
-  using KeyTy = std::tuple<Type, Dialect *, StringRef>;
-
-  OpaqueElementsAttributeStorage(Type type, Dialect *dialect, StringRef bytes)
-      : AttributeStorage(type), dialect(dialect), bytes(bytes) {}
-
-  /// Key equality and hash functions.
-  bool operator==(const KeyTy &key) const {
-    return key == std::make_tuple(getType(), dialect, bytes);
-  }
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_combine(std::get<0>(key), std::get<1>(key),
-                              std::get<2>(key));
-  }
-
-  /// Construct a new storage instance.
-  static OpaqueElementsAttributeStorage *
-  construct(AttributeStorageAllocator &allocator, KeyTy key) {
-    // TODO: Provide a way to avoid copying content of large opaque
-    // tensors This will likely require a new reference attribute kind.
-    return new (allocator.allocate<OpaqueElementsAttributeStorage>())
-        OpaqueElementsAttributeStorage(std::get<0>(key), std::get<1>(key),
-                                       allocator.copyInto(std::get<2>(key)));
-  }
-
-  Dialect *dialect;
-  StringRef bytes;
-};
-
-/// An attribute representing a reference to a sparse vector or tensor object.
-struct SparseElementsAttributeStorage : public AttributeStorage {
-  using KeyTy = std::tuple<Type, DenseIntElementsAttr, DenseElementsAttr>;
-
-  SparseElementsAttributeStorage(Type type, DenseIntElementsAttr indices,
-                                 DenseElementsAttr values)
-      : AttributeStorage(type), indices(indices), values(values) {}
-
-  /// Key equality and hash functions.
-  bool operator==(const KeyTy &key) const {
-    return key == std::make_tuple(getType(), indices, values);
-  }
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_combine(std::get<0>(key), std::get<1>(key),
-                              std::get<2>(key));
-  }
-
-  /// Construct a new storage instance.
-  static SparseElementsAttributeStorage *
-  construct(AttributeStorageAllocator &allocator, KeyTy key) {
-    return new (allocator.allocate<SparseElementsAttributeStorage>())
-        SparseElementsAttributeStorage(std::get<0>(key), std::get<1>(key),
-                                       std::get<2>(key));
-  }
-
-  DenseIntElementsAttr indices;
-  DenseElementsAttr values;
-};
 } // namespace detail
 } // namespace mlir
 
 #endif // ATTRIBUTEDETAIL_H_

mlir/lib/IR/BuiltinAttributes.cpp

 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
   return Base::get(context, ArrayRef<NamedAttribute>());
 }
 
 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
 
-FloatAttr FloatAttr::get(Type type, double value) {
-  return Base::get(type.getContext(), type, value);
-}
-
-FloatAttr FloatAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
-                                Type type, double value) {
-  return Base::getChecked(emitError, type.getContext(), type, value);
-}
-
-FloatAttr FloatAttr::get(Type type, const APFloat &value) {
-  return Base::get(type.getContext(), type, value);
-}
-
-FloatAttr FloatAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
-                                Type type, const APFloat &value) {
-  return Base::getChecked(emitError, type.getContext(), type, value);
-}
-
-APFloat FloatAttr::getValue() const { return getImpl()->getValue(); }
-
 double FloatAttr::getValueAsDouble() const {
   return getValueAsDouble(getValue());
 }
 double FloatAttr::getValueAsDouble(APFloat value) {
   if (&value.getSemantics() != &APFloat::IEEEdouble()) {
     bool losesInfo = false;
     value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                   &losesInfo);
   }
   return value.convertToDouble();
 }
 
-/// Verify construction invariants.
-static LogicalResult
-verifyFloatTypeInvariants(function_ref<InFlightDiagnostic()> emitError,
-                          Type type) {
-  if (!type.isa<FloatType>())
-    return emitError() << "expected floating point type";
-  return success();
-}
-
-LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                                Type type, double value) {
-  return verifyFloatTypeInvariants(emitError, type);
-}
-
 LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                                Type type, const APFloat &value) {
+                                Type type, APFloat value) {
   // Verify that the type is correct.
-  if (failed(verifyFloatTypeInvariants(emitError, type)))
-    return failure();
+  if (!type.isa<FloatType>())
+    return emitError() << "expected floating point type";
 
   // Verify that the type semantics match that of the value.
   if (&type.cast<FloatType>().getFloatSemantics() != &value.getSemantics()) {
     return emitError()
            << "FloatAttr type doesn't match the type implied by its value";
   }
   return success();
 }
StringRef SymbolRefAttr::getLeafReference() const {
   ArrayRef<FlatSymbolRefAttr> nestedRefs = getNestedReferences();
   return nestedRefs.empty() ? getRootReference() : nestedRefs.back().getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // IntegerAttr
 //===----------------------------------------------------------------------===//
 
-IntegerAttr IntegerAttr::get(Type type, const APInt &value) {
-  if (type.isSignlessInteger(1))
-    return BoolAttr::get(type.getContext(), value.getBoolValue());
-  return Base::get(type.getContext(), type, value);
-}
-
-IntegerAttr IntegerAttr::get(Type type, int64_t value) {
-  // This uses 64 bit APInts by default for index type.
-  if (type.isIndex())
-    return get(type, APInt(IndexType::kInternalStorageBitWidth, value));
-
-  auto intType = type.cast<IntegerType>();
-  return get(type, APInt(intType.getWidth(), value, intType.isSignedInteger()));
-}
-
-APInt IntegerAttr::getValue() const { return getImpl()->getValue(); }
-
 int64_t IntegerAttr::getInt() const {
-  assert((getImpl()->getType().isIndex() ||
-          getImpl()->getType().isSignlessInteger()) &&
+  assert((getType().isIndex() || getType().isSignlessInteger()) &&
          "must be signless integer");
   return getValue().getSExtValue();
 }
 
 int64_t IntegerAttr::getSInt() const {
-  assert(getImpl()->getType().isSignedInteger() && "must be signed integer");
+  assert(getType().isSignedInteger() && "must be signed integer");
   return getValue().getSExtValue();
 }
 
 uint64_t IntegerAttr::getUInt() const {
-  assert(getImpl()->getType().isUnsignedInteger() &&
-         "must be unsigned integer");
+  assert(getType().isUnsignedInteger() && "must be unsigned integer");
   return getValue().getZExtValue();
 }
 
-static LogicalResult
-verifyIntegerTypeInvariants(function_ref<InFlightDiagnostic()> emitError,
-                            Type type) {
-  if (type.isa<IntegerType, IndexType>())
-    return success();
-  return emitError() << "expected integer or index type";
-}
-
 LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                                  Type type, int64_t value) {
-  return verifyIntegerTypeInvariants(emitError, type);
-}
-
-LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                                  Type type, const APInt &value) {
-  if (failed(verifyIntegerTypeInvariants(emitError, type)))
-    return failure();
-  if (auto integerType = type.dyn_cast<IntegerType>())
+                                  Type type, APInt value) {
+  if (IntegerType integerType = type.dyn_cast<IntegerType>()) {
     if (integerType.getWidth() != value.getBitWidth())
       return emitError() << "integer type bit width (" << integerType.getWidth()
                          << ") doesn't match value bit width ("
                          << value.getBitWidth() << ")";
     return success();
   }
+  if (type.isa<IndexType>())
+    return success();
+  return emitError() << "expected integer or index type";
+}
+
+BoolAttr IntegerAttr::getBoolAttrUnchecked(IntegerType type, bool value) {
+  auto attr = Base::get(type.getContext(), type, APInt(/*numBits=*/1, value));
+  return attr.cast<BoolAttr>();
+}
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
 
 bool BoolAttr::getValue() const {
-  auto *storage = reinterpret_cast<IntegerAttributeStorage *>(impl);
-  return storage->getValue().getBoolValue();
+  auto *storage = reinterpret_cast<IntegerAttrStorage *>(impl);
+  return storage->value.getBoolValue();
 }
 
 bool BoolAttr::classof(Attribute attr) {
   IntegerAttr intAttr = attr.dyn_cast<IntegerAttr>();
   return intAttr && intAttr.getType().isSignlessInteger(1);
 }
 
 //===----------------------------------------------------------------------===//
auto DenseElementsAttr::getComplexFloatValues() const
   assert(eltTy.isa<FloatType>() && "expected complex float type");
   const auto &semantics = eltTy.cast<FloatType>().getFloatSemantics();
   return {{semantics, {*this, 0}},
           {semantics, {*this, static_cast<size_t>(getNumElements())}}};
 }
 
 /// Return the raw storage data held by this attribute.
 ArrayRef<char> DenseElementsAttr::getRawData() const {
-  return static_cast<DenseIntOrFPElementsAttributeStorage *>(impl)->data;
+  return static_cast<DenseIntOrFPElementsAttrStorage *>(impl)->data;
 }
 
 ArrayRef<StringRef> DenseElementsAttr::getRawStringData() const {
-  return static_cast<DenseStringElementsAttributeStorage *>(impl)->data;
+  return static_cast<DenseStringElementsAttrStorage *>(impl)->data;
 }
 
 /// Return a new DenseElementsAttr that has the same data as the current
 /// attribute, but has been reshaped to 'newType'. The new type must have the
 /// same total number of elements as well as element type.
 DenseElementsAttr DenseElementsAttr::reshape(ShapedType newType) {
   ShapedType curType = getType();
   if (curType == newType)

 }
 
 DenseElementsAttr DenseElementsAttr::mapValues(
     Type newElementType, function_ref<APInt(const APFloat &)> mapping) const {
   return cast<DenseFPElementsAttr>().mapValues(newElementType, mapping);
 }
 
 //===----------------------------------------------------------------------===//
-// DenseStringElementsAttr
-//===----------------------------------------------------------------------===//
-
-DenseStringElementsAttr
-DenseStringElementsAttr::get(ShapedType type, ArrayRef<StringRef> values) {
-  return Base::get(type.getContext(), type, values, (values.size() == 1));
-}
-
-//===----------------------------------------------------------------------===//
 // DenseIntOrFPElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Utility method to write a range of APInt values to a buffer.
 template <typename APRangeT>
 static void writeAPIntsToBuffer(size_t storageWidth, std::vector<char> &data,
                                 APRangeT &&values) {
   data.resize(llvm::divideCeil(storageWidth, CHAR_BIT) * llvm::size(values));
bool DenseIntElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseElementsAttr>() &&
          attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueElementsAttr
 //===----------------------------------------------------------------------===//
 
-OpaqueElementsAttr OpaqueElementsAttr::get(Dialect *dialect, ShapedType type,
-                                           StringRef bytes) {
-  assert(TensorType::isValidElementType(type.getElementType()) &&
-         "Input element type should be a valid tensor element type");
-  return Base::get(type.getContext(), type, dialect, bytes);
-}
-
-StringRef OpaqueElementsAttr::getValue() const { return getImpl()->bytes; }
-
 /// Return the value at the given index. If index does not refer to a valid
 /// element, then a null attribute is returned.
 Attribute OpaqueElementsAttr::getValue(ArrayRef<uint64_t> index) const {
   assert(isValidIndex(index) && "expected valid multi-dimensional index");
   return Attribute();
 }
 
-Dialect *OpaqueElementsAttr::getDialect() const { return getImpl()->dialect; }
-
 bool OpaqueElementsAttr::decode(ElementsAttr &result) {
-  auto *d = getDialect();
-  if (!d)
+  Dialect *dialect = getDialect().getDialect();
+  if (!dialect)
     return true;
   auto *interface =
-      d->getRegisteredInterface<DialectDecodeAttributesInterface>();
+      dialect->getRegisteredInterface<DialectDecodeAttributesInterface>();
   if (!interface)
     return true;
   return failed(interface->decode(*this, result));
 }
 
+LogicalResult
+OpaqueElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                           Identifier dialect, StringRef value,
+                           ShapedType type) {
+  if (!Dialect::isValidNamespace(dialect.strref()))
+    return emitError() << "invalid dialect namespace '" << dialect << "'";
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
-SparseElementsAttr SparseElementsAttr::get(ShapedType type,
-                                           DenseElementsAttr indices,
-                                           DenseElementsAttr values) {
-  assert(indices.getType().getElementType().isInteger(64) &&
-         "expected sparse indices to be 64-bit integer values");
-  assert((type.isa<RankedTensorType, VectorType>()) &&
-         "type must be ranked tensor or vector");
-  assert(type.hasStaticShape() && "type must have static shape");
-  return Base::get(type.getContext(), type,
-                   indices.cast<DenseIntElementsAttr>(), values);
-}
-
-DenseIntElementsAttr SparseElementsAttr::getIndices() const {
-  return getImpl()->indices;
-}
-
-DenseElementsAttr SparseElementsAttr::getValues() const {
-  return getImpl()->values;
-}
-
 /// Return the value of the element at the given index.
 Attribute SparseElementsAttr::getValue(ArrayRef<uint64_t> index) const {
   assert(isValidIndex(index) && "expected valid multi-dimensional index");
   auto type = getType();
 
   // The sparse indices are 64-bit integers, so we can reinterpret the raw data
   // as a 1-D index array.
   auto sparseIndices = getIndices();

mlir/lib/IR/MLIRContext.cpp

MLIRContext::MLIRContext(const DialectRegistry &registry)
   impl->int128Ty =
       TypeUniquer::get<IntegerType>(this, 128, IntegerType::Signless);
   /// None Type.
   impl->noneType = TypeUniquer::get<NoneType>(this);
 
   //// Attributes.
   //// Note: These must be registered after the types as they may generate one
   //// of the above types internally.
+  /// Unknown Location Attribute.
+  impl->unknownLocAttr = AttributeUniquer::get<UnknownLoc>(this);
   /// Bool Attributes.
-  impl->falseAttr = AttributeUniquer::get<IntegerAttr>(
-                        this, impl->int1Ty, APInt(/*numBits=*/1, false))
-                        .cast<BoolAttr>();
-  impl->trueAttr = AttributeUniquer::get<IntegerAttr>(
-                       this, impl->int1Ty, APInt(/*numBits=*/1, true))
-                       .cast<BoolAttr>();
+  impl->falseAttr = IntegerAttr::getBoolAttrUnchecked(impl->int1Ty, false);
+  impl->trueAttr = IntegerAttr::getBoolAttrUnchecked(impl->int1Ty, true);
   /// Unit Attribute.
   impl->unitAttr = AttributeUniquer::get<UnitAttr>(this);
-  /// Unknown Location Attribute.
-  impl->unknownLocAttr = AttributeUniquer::get<UnknownLoc>(this);
   /// The empty dictionary attribute.
   impl->emptyDictionaryAttr = DictionaryAttr::getEmptyUnchecked(this);
 
   // Register the affine storage objects with the uniquer.
   impl->affineUniquer
       .registerParametricStorageType<AffineBinaryOpExprStorage>();
   impl->affineUniquer
       .registerParametricStorageType<AffineConstantExprStorage>();

mlir/lib/Parser/AttributeParser.cpp

 Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
   consumeToken(Token::kw_opaque);
   if (parseToken(Token::less, "expected '<' after 'opaque'"))
     return nullptr;
 
   if (getToken().isNot(Token::string))
     return (emitError("expected dialect namespace"), nullptr);
 
-  auto name = getToken().getStringValue();
-  // Lazy load a dialect in the context if there is a possible namespace.
-  Dialect *dialect = builder.getContext()->getOrLoadDialect(name);
-
-  // TODO: Allow for having an unknown dialect on an opaque
-  // attribute. Otherwise, it can't be roundtripped without having the dialect
-  // registered.
-  if (!dialect)
-    return (emitError("no registered dialect with namespace '" + name + "'"),
-            nullptr);
+  std::string name = getToken().getStringValue();
   consumeToken(Token::string);
 
   if (parseToken(Token::comma, "expected ','"))
     return nullptr;
 
   Token hexTok = getToken();
   if (parseToken(Token::string, "elements hex string should start with '0x'") ||
       parseToken(Token::greater, "expected '>'"))
     return nullptr;
   auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
 
   std::string data;
   if (parseElementAttrHexValues(*this, hexTok, data))
     return nullptr;
-  return OpaqueElementsAttr::get(dialect, type, data);
+  return OpaqueElementsAttr::get(builder.getIdentifier(name), type, data);
 }
 
 /// Shaped type for elements attribute.
 ///
 ///   elements-literal-type ::= vector-type | ranked-tensor-type
 ///
 /// This method also checks the type has static shape.
 ShapedType Parser::parseElementsLiteralType(Type type) {

mlir/lib/TableGen/AttrOrTypeDef.cpp

for (llvm::Init *init : builderList->getValues()) {
       // Ensure that all parameters have names.
       for (const AttrOrTypeBuilder::Parameter &param :
            builder.getParameters()) {
         if (!param.getName())
           PrintFatalError(def->getLoc(), "builder parameters must have a name");
       }
       builders.emplace_back(builder);
     }
-  } else if (skipDefaultBuilders()) {
-    PrintFatalError(
-        def->getLoc(),
-        "default builders are skipped and no custom builders provided");
   }
 }
 
 Dialect AttrOrTypeDef::getDialect() const {
   auto *dialect = dyn_cast<llvm::DefInit>(def->getValue("dialect")->getValue());
   return Dialect(dialect ? dialect->getDef() : nullptr);
 }
 

mlir/test/CAPI/ir.c

static void printFirstOfEach(MlirContext ctx, MlirOperation operation) {
   mlirOpPrintingFlagsElideLargeElementsAttrs(flags, 2);
   mlirOpPrintingFlagsPrintGenericOpForm(flags);
   mlirOpPrintingFlagsEnableDebugInfo(flags, /*prettyForm=*/0);
   mlirOpPrintingFlagsUseLocalScope(flags);
   fprintf(stderr, "Op print with all flags: ");
   mlirOperationPrintWithFlags(operation, flags, printToStderr, NULL);
   fprintf(stderr, "\n");
   // clang-format off
-  // CHECK: Op print with all flags: %{{.*}} = "std.constant"() {elts = opaque<"", "0xDEADBEEF"> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
+  // CHECK: Op print with all flags: %{{.*}} = "std.constant"() {elts = opaque<"_", "0xDEADBEEF"> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
   // clang-format on
 
   mlirOpPrintingFlagsDestroy(flags);
 }
 
 static int constructAndTraverseIr(MlirContext ctx) {
   MlirLocation location = mlirLocationUnknownGet(ctx);
 

mlir/test/IR/invalid.mlir

 ^bb0:
   "foo"(){bar = opaque<10, "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected dialect namespace}}
 }
 
 // -----
 
 func @elementsattr_malformed_opaque1() -> () {
 ^bb0:
-  "foo"(){bar = opaque<"", "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
+  "foo"(){bar = opaque<"_", "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
 }
 
 // -----
 
 func @elementsattr_malformed_opaque2() -> () {
 ^bb0:
-  "foo"(){bar = opaque<"", "00abc"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
-}
-
-// -----
-
-func @elementsattr_malformed_opaque3() -> () {
-^bb0:
-  "foo"(){bar = opaque<"t", "0xabc"> : tensor<1xi8>} : () -> () // expected-error {{no registered dialect with namespace 't'}}
+  "foo"(){bar = opaque<"_", "00abc"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
 }
 
 // -----
 
 func @redundant_signature(%a : i32) -> () {
 ^bb0(%b : i32):  // expected-error {{invalid block name in region with named arguments}}
   return
 }

 !redef_alias = type i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
 
 // -----
 
 // Check ill-formed opaque tensor.
 func @complex_loops() {
   affine.for %i1 = 1 to 100 {
   // expected-error @+1 {{expected '"' in string literal}}
-  "opaqueIntTensor"(){bar = opaque<"", "0x686]> : tensor<2x1x4xi32>} : () -> ()
+  "opaqueIntTensor"(){bar = opaque<"_", "0x686]> : tensor<2x1x4xi32>} : () -> ()
 
 // -----
 
 func @mi() {
   // expected-error @+1 {{expected element literal of primitive type}}
   "fooi64"(){bar = sparse<vector<1xi64>,[,[,1]
 
 // -----

mlir/test/IR/pretty-attributes.mlir

 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | FileCheck %s
 // Ensure that the elided version is still parseable, although depending on
 // what has been elided, it may not be semantically meaningful.
 // In the typical case where what is being elided is a very large constant
 // tensor which passes don't look at directly, this isn't an issue.
 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | mlir-opt
 
-// CHECK: opaque<"", "0xDEADBEEF"> : tensor<3xi32>
+// CHECK: opaque<"_", "0xDEADBEEF"> : tensor<3xi32>
 "test.dense_attr"() {foo.dense_attr = dense<[1, 2, 3]> : tensor<3xi32>} : () -> ()
 
 // CHECK: dense<[1, 2]> : tensor<2xi32>
 "test.non_elided_dense_attr"() {foo.dense_attr = dense<[1, 2]> : tensor<2xi32>} : () -> ()
 
-// CHECK: opaque<"", "0xDEADBEEF"> : vector<1x1x1xf16>
+// CHECK: opaque<"_", "0xDEADBEEF"> : vector<1x1x1xf16>
 "test.sparse_attr"() {foo.sparse_attr = sparse<[[1, 2, 3]],  -2.0> : vector<1x1x1xf16>} : () -> ()
 
-// CHECK: opaque<"", "0xDEADBEEF"> : tensor<100xf32>
-"test.opaque_attr"() {foo.opaque_attr = opaque<"", "0xEBFE"> : tensor<100xf32> } : () -> ()
+// CHECK: opaque<"_", "0xDEADBEEF"> : tensor<100xf32>
+"test.opaque_attr"() {foo.opaque_attr = opaque<"_", "0xEBFE"> : tensor<100xf32> } : () -> ()
 
 // CHECK: dense<1> : tensor<3xi32>
 "test.dense_splat"() {foo.dense_attr = dense<1> : tensor<3xi32>} : () -> ()

mlir/test/mlir-tblgen/attrdefs.td

 // DEF-NEXT: if (!(getType() == std::get<4>(key)))
 // DEF-NEXT:   return false;
 // DEF-NEXT: return true;
 
 // DEF: static CompoundAAttrStorage *construct
 // DEF: return new (allocator.allocate<CompoundAAttrStorage>())
 // DEF-NEXT: CompoundAAttrStorage(widthOfSomething, exampleTdType, apFloat, dims, inner);
 
-// DEF: ::mlir::Type CompoundAAttr::getInner() const { return getImpl()->getType(); }
+// DEF: ::mlir::Type CompoundAAttr::getInner() const { return getImpl()->getType().cast<::mlir::Type>(); }
 }
 
 def C_IndexAttr : TestAttr<"Index"> {
     let mnemonic = "index";
 
     let parameters = (
       ins
       StringRefParameter<"Label for index">:$label

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

if (def.genStorageClass())
       emitStorageClass(def);
 
     // Emit the builders for this def.
     emitBuilderDefs(def, os, parameters);
 
     // Generate accessor definitions only if we also generate the storage class.
     // Otherwise, let the user define the exact accessor definition.
     if (def.genAccessors() && def.genStorageClass()) {
-      for (const AttrOrTypeParameter &parameter : parameters) {
-        StringRef paramStorageName = isa<AttributeSelfTypeParameter>(parameter)
-                                         ? "getType()"
-                                         : parameter.getName();
+      for (const AttrOrTypeParameter &param : parameters) {
+        SmallString<32> paramStorageName;
+        if (isa<AttributeSelfTypeParameter>(param)) {
+          Twine("getType().cast<" + param.getCppType() + ">()")
+              .toVector(paramStorageName);
+        } else {
+          paramStorageName = param.getName();
+        }
 
-        SmallString<16> name = parameter.getName();
+        SmallString<16> name = param.getName();
         name[0] = llvm::toUpper(name[0]);
         os << formatv("{0} {3}::get{1}() const {{ return getImpl()->{2}; }\n",
-                      parameter.getCppType(), name, paramStorageName,
+                      param.getCppType(), name, paramStorageName,
                       def.getCppClassName());
       }
     }
   }
 
   // If mnemonic is specified maybe print definitions for the parser and printer
   // code, if they're specified.
   if (def.getMnemonic())