[mlir][Python] Add python binding to create DenseElementsAttribute.

[stellaraccident]

Summary

• Interops with Python buffers/numpy arrays to create.
• Also cleans up 'get' factory methods on some types to be consistent.
• Adds mlirAttributeGetType() to C-API to facilitate error handling and other uses.
• Punts on a lot of features of the ElementsAttribute hierarchy for now.
• Does not yet support bool or string attributes.

[zhanghb97]

mlir/lib/Bindings/Python/IRModules.cpp

1052

Why only consider tensor here? Should we also consider the vector case?

mlir/test/Bindings/Python/ir_array_attributes.py

7

I have numpy in my environment, so there is no problem. I'm wondering if the numpy is not installed, will the test fail?

[stellaraccident]

mlir/lib/Bindings/Python/IRModules.cpp

1052

It's a fairly complicated API to use with all options exposed, and I wanted the default "import from array" case to just work without a lot of fiddling for a dominant case. I'll add a TODO to add optional args to control which shaped type gets used. I'll also extend the docs.

mlir/test/Bindings/Python/ir_array_attributes.py

7

Currently, yes. I'll address any issues here even we enable this by default in the build.

[stellaraccident]

Split change.

[zhanghb97]

mlir/lib/Bindings/Python/IRModules.cpp

930

Now it seems that the view is freed correctly only when the calling PyObject_GetBuffer fails. But successful calls to PyObject_GetBuffer have no paired with calls to PyBuffer_Release when the attribute object ends its lifetime, I think it may cause resource leaks.

[stellaraccident]

mlir/lib/Bindings/Python/IRModules.cpp

930

Nice to be looking for it, but in this case it is safe because the py::buffer_info constructor defaults to stealing the Py_buffer* and will free it upon going out of scope.

Fwiw, I'm using a relatively unconventional way of getting the buffer_info here, resorting to the underlying C functions because I want to cast it to specific constraints so that I know it will line up with the memory format for constructing dense elements attributes. A lot of code that accesses a buffer doesn't do this and you won't see these extra coercions and error checking.

mlir/include/mlir-c/IR.h

 /*============================================================================*/
 
 /** Parses an attribute. The attribute is owned by the context. */
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr);
 
 /** Gets the context that an attribute was created with. */
 MlirContext mlirAttributeGetContext(MlirAttribute attribute);
 
+/** Gets the type of this attribute. */
+MlirType mlirAttributeGetType(MlirAttribute attribute);
+
 /** Checks whether an attribute is null. */
 static inline int mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
 
 /** Checks if two attributes are equal. */
 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
 
 /** Prints an attribute by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called

mlir/include/mlir-c/StandardAttributes.h

MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
                                                  float element);
 MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
                                                   double element);
 
 /** Creates a dense elements attribute with the given shaped type from elements
  * of a specific type. Expects the element type of the shaped type to match the
  * data element type. */
 MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
-                                           intptr_t numElements, int *elements);
+                                           intptr_t numElements,
+                                           const int *elements);
 MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
                                              intptr_t numElements,
-                                             uint32_t *elements);
+                                             const uint32_t *elements);
 MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
                                             intptr_t numElements,
-                                            int32_t *elements);
+                                            const int32_t *elements);
 MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
                                              intptr_t numElements,
-                                             uint64_t *elements);
+                                             const uint64_t *elements);
 MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
                                             intptr_t numElements,
-                                            int64_t *elements);
+                                            const int64_t *elements);
 MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
                                             intptr_t numElements,
-                                            float *elements);
+                                            const float *elements);
 MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
                                              intptr_t numElements,
-                                             double *elements);
+                                             const double *elements);
 
 /** Creates a dense elements attribute with the given shaped type from string
  * elements. The strings need not be null-terminated and their lengths are
  * provided as a separate argument co-indexed with the strs argument. */
 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                              intptr_t numElements,
                                              intptr_t *strLengths,
                                              const char **strs);

mlir/lib/Bindings/Python/IRModules.cpp

c.def_property_readonly(
         [](PyStringAttribute &self) {
           MlirStringRef stringRef = mlirStringAttrGetValue(self.attr);
           return py::str(stringRef.data, stringRef.length);
         },
         "Returns the value of the string attribute");
   }
 };
 
+// TODO: Support construction of bool elements.
+// TODO: Support construction of string elements.
+class PyDenseElementsAttribute
+    : public PyConcreteAttribute<PyDenseElementsAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseElements;
+  static constexpr const char *pyClassName = "DenseElementsAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static PyDenseElementsAttribute getFromBuffer(PyMlirContext &contextWrapper,
+                                                py::buffer array,
+                                                bool signless) {
+    // Request a contiguous view. In exotic cases, this will cause a copy.
+    int flags = PyBUF_C_CONTIGUOUS | PyBUF_FORMAT;
+    Py_buffer *view = new Py_buffer();
+    if (PyObject_GetBuffer(array.ptr(), view, flags) != 0) {
+      delete view;
+      throw py::error_already_set();
+    }
+    py::buffer_info arrayInfo(view);
+
+    MlirContext context = contextWrapper.get();
+    // Switch on the types that can be bulk loaded between the Python and
+    // MLIR-C APIs.
+    if (arrayInfo.format == "f") {
+      // f32
+      assert(arrayInfo.itemsize == 4 && "mismatched array itemsize");
+      return PyDenseElementsAttribute(
+          contextWrapper.getRef(),
+          bulkLoad(context, mlirDenseElementsAttrFloatGet,
+                   mlirF32TypeGet(context), arrayInfo));
+    } else if (arrayInfo.format == "d") {
+      // f64
+      assert(arrayInfo.itemsize == 8 && "mismatched array itemsize");
+      return PyDenseElementsAttribute(
+          contextWrapper.getRef(),
+          bulkLoad(context, mlirDenseElementsAttrDoubleGet,
+                   mlirF64TypeGet(context), arrayInfo));
+    } else if (arrayInfo.format == "i") {
+      // i32
+      assert(arrayInfo.itemsize == 4 && "mismatched array itemsize");
+      MlirType elementType = signless ? mlirIntegerTypeGet(context, 32)
+                                      : mlirIntegerTypeSignedGet(context, 32);
+      return PyDenseElementsAttribute(contextWrapper.getRef(),
+                                      bulkLoad(context,
+                                               mlirDenseElementsAttrInt32Get,
+                                               elementType, arrayInfo));
+    } else if (arrayInfo.format == "I") {
+      // unsigned i32
+      assert(arrayInfo.itemsize == 4 && "mismatched array itemsize");
+      MlirType elementType = signless ? mlirIntegerTypeGet(context, 32)
+                                      : mlirIntegerTypeUnsignedGet(context, 32);
+      return PyDenseElementsAttribute(contextWrapper.getRef(),
+                                      bulkLoad(context,
+                                               mlirDenseElementsAttrUInt32Get,
+                                               elementType, arrayInfo));
+    } else if (arrayInfo.format == "l") {
+      // i64
+      assert(arrayInfo.itemsize == 8 && "mismatched array itemsize");
+      MlirType elementType = signless ? mlirIntegerTypeGet(context, 64)
+                                      : mlirIntegerTypeSignedGet(context, 64);
+      return PyDenseElementsAttribute(contextWrapper.getRef(),
+                                      bulkLoad(context,
+                                               mlirDenseElementsAttrInt64Get,
+                                               elementType, arrayInfo));
+    } else if (arrayInfo.format == "L") {
+      // unsigned i64
+      assert(arrayInfo.itemsize == 8 && "mismatched array itemsize");
+      MlirType elementType = signless ? mlirIntegerTypeGet(context, 64)
+                                      : mlirIntegerTypeUnsignedGet(context, 64);
+      return PyDenseElementsAttribute(contextWrapper.getRef(),
+                                      bulkLoad(context,
+                                               mlirDenseElementsAttrUInt64Get,
+                                               elementType, arrayInfo));
+    }
+
+    // TODO: Fall back to string-based get.
+    std::string message = "unimplemented array format conversion from format: ";
+    message.append(arrayInfo.format);
+    throw SetPyError(PyExc_ValueError, message);
+  }
+
+  static PyDenseElementsAttribute getSplat(PyType shapedType,
+                                           PyAttribute &elementAttr) {
+    auto contextWrapper =
+        PyMlirContext::forContext(mlirTypeGetContext(shapedType));
+    if (!mlirAttributeIsAInteger(elementAttr.attr) &&
+        !mlirAttributeIsAFloat(elementAttr.attr)) {
+      std::string message = "Illegal element type for DenseElementsAttr: ";
+      message.append(py::repr(py::cast(elementAttr)));
+      throw SetPyError(PyExc_ValueError, message);
+    }
+    if (!mlirTypeIsAShaped(shapedType) ||
+        !mlirShapedTypeHasStaticShape(shapedType)) {
+      std::string message =
+          "Expected a static ShapedType for the shaped_type parameter: ";
+      message.append(py::repr(py::cast(shapedType)));
+      throw SetPyError(PyExc_ValueError, message);
+    }
+    MlirType shapedElementType = mlirShapedTypeGetElementType(shapedType.type);
+    MlirType attrType = mlirAttributeGetType(elementAttr.attr);
+    if (!mlirTypeEqual(shapedElementType, attrType)) {
+      std::string message =
+          "Shaped element type and attribute type must be equal: shaped=";
+      message.append(py::repr(py::cast(shapedType)));
+      message.append(", element=");
+      message.append(py::repr(py::cast(elementAttr)));
+      throw SetPyError(PyExc_ValueError, message);
+    }
+
+    MlirAttribute elements =
+        mlirDenseElementsAttrSplatGet(shapedType.type, elementAttr.attr);
+    return PyDenseElementsAttribute(contextWrapper->getRef(), elements);
+  }
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static("get", PyDenseElementsAttribute::getFromBuffer,
+                 py::arg("context"), py::arg("array"),
+                 py::arg("signless") = true, "Gets from a buffer or ndarray")
+        .def_static("get_splat", PyDenseElementsAttribute::getSplat,
+                    py::arg("shaped_type"), py::arg("element_attr"),
+                    "Gets a DenseElementsAttr where all values are the same")
+        .def_property_readonly("is_splat",
+                               [](PyDenseElementsAttribute &self) -> bool {
+                                 return mlirDenseElementsAttrIsSplat(self.attr);
+                               });
+  }
+
+private:
+  template <typename ElementTy>
+  static MlirAttribute
+  bulkLoad(MlirContext context,
+           MlirAttribute (*ctor)(MlirType, intptr_t, ElementTy *),
+           MlirType mlirElementType, py::buffer_info &arrayInfo) {
+    SmallVector<int64_t, 4> shape(arrayInfo.shape.begin(),
+                                  arrayInfo.shape.begin() + arrayInfo.ndim);
+    auto shapedType =
+        mlirRankedTensorTypeGet(shape.size(), shape.data(), mlirElementType);
+    intptr_t numElements = arrayInfo.size;
+    const ElementTy *contents = static_cast<const ElementTy *>(arrayInfo.ptr);
+    return ctor(shapedType, numElements, contents);
+  }
+};
+
 } // namespace
 
 //------------------------------------------------------------------------------
 // Standard type subclasses.
 //------------------------------------------------------------------------------
 
 namespace {
 

 /// Index Type subclass - IndexType.
 class PyIndexType : public PyConcreteType<PyIndexType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAIndex;
   static constexpr const char *pyClassName = "IndexType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirIndexTypeGet(context.get());
-            return PyIndexType(context.getRef(), t);
-          }),
-          "Create a index type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// Floating Point Type subclass - BF16Type.
 class PyBF16Type : public PyConcreteType<PyBF16Type> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsABF16;
   static constexpr const char *pyClassName = "BF16Type";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirBF16TypeGet(context.get());
-            return PyBF16Type(context.getRef(), t);
-          }),
-          "Create a bf16 type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// Floating Point Type subclass - F16Type.
 class PyF16Type : public PyConcreteType<PyF16Type> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAF16;
   static constexpr const char *pyClassName = "F16Type";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirF16TypeGet(context.get());
-            return PyF16Type(context.getRef(), t);
-          }),
-          "Create a f16 type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// Floating Point Type subclass - F32Type.
 class PyF32Type : public PyConcreteType<PyF32Type> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAF32;
   static constexpr const char *pyClassName = "F32Type";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirF32TypeGet(context.get());
-            return PyF32Type(context.getRef(), t);
-          }),
-          "Create a f32 type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// Floating Point Type subclass - F64Type.
 class PyF64Type : public PyConcreteType<PyF64Type> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAF64;
   static constexpr const char *pyClassName = "F64Type";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirF64TypeGet(context.get());
-            return PyF64Type(context.getRef(), t);
-          }),
-          "Create a f64 type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// None Type subclass - NoneType.
 class PyNoneType : public PyConcreteType<PyNoneType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsANone;
   static constexpr const char *pyClassName = "NoneType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
-    c.def(py::init([](PyMlirContext &context) {
-            MlirType t = mlirNoneTypeGet(context.get());
-            return PyNoneType(context.getRef(), t);
-          }),
-          "Create a none type.");
+    c.def_static(
+        "get",
+        [](PyMlirContext &context) {
+        },
   }
 };
 
 /// Complex Type subclass - ComplexType.
 class PyComplexType : public PyConcreteType<PyComplexType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAComplex;
   static constexpr const char *pyClassName = "ComplexType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-        "get_complex",
+        "get",
         [](PyType &elementType) {
           // The element must be a floating point or integer scalar type.
           if (mlirTypeIsAIntegerOrFloat(elementType.type)) {
             MlirType t = mlirComplexTypeGet(elementType.type);
             return PyComplexType(elementType.getContext(), t);
           }
           throw SetPyError(
               PyExc_ValueError,

 class PyVectorType : public PyConcreteType<PyVectorType, PyShapedType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAVector;
   static constexpr const char *pyClassName = "VectorType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-        "get_vector",
+        "get",
         // TODO: Make the location optional and create a default location.
         [](std::vector<int64_t> shape, PyType &elementType, PyLocation &loc) {
           MlirType t = mlirVectorTypeGetChecked(shape.size(), shape.data(),
                                                 elementType.type, loc.loc);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
class PyRankedTensorType
     : public PyConcreteType<PyRankedTensorType, PyShapedType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsARankedTensor;
   static constexpr const char *pyClassName = "RankedTensorType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-        "get_ranked_tensor",
+        "get",
         // TODO: Make the location optional and create a default location.
         [](std::vector<int64_t> shape, PyType &elementType, PyLocation &loc) {
           MlirType t = mlirRankedTensorTypeGetChecked(
               shape.size(), shape.data(), elementType.type, loc.loc);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
class PyUnrankedTensorType
     : public PyConcreteType<PyUnrankedTensorType, PyShapedType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAUnrankedTensor;
   static constexpr const char *pyClassName = "UnrankedTensorType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-        "get_unranked_tensor",
+        "get",
         // TODO: Make the location optional and create a default location.
         [](PyType &elementType, PyLocation &loc) {
           MlirType t =
               mlirUnrankedTensorTypeGetChecked(elementType.type, loc.loc);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
class PyUnrankedMemRefType
     : public PyConcreteType<PyUnrankedMemRefType, PyShapedType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAUnrankedMemRef;
   static constexpr const char *pyClassName = "UnrankedMemRefType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-         "get_unranked_memref",
+         "get",
          // TODO: Make the location optional and create a default location.
          [](PyType &elementType, unsigned memorySpace, PyLocation &loc) {
            MlirType t = mlirUnrankedMemRefTypeGetChecked(elementType.type,
                                                          memorySpace, loc.loc);
            // TODO: Rework error reporting once diagnostic engine is exposed
            // in C API.
            if (mlirTypeIsNull(t)) {
              throw SetPyError(
py::class_<PyBlock>(m, "Block")
           kTypeStrDunderDocstring);
 
   // Mapping of Type.
   py::class_<PyAttribute>(m, "Attribute")
       .def_property_readonly(
           "context",
           [](PyAttribute &self) { return self.getContext().getObject(); },
           "Context that owns the Attribute")
+      .def_property_readonly("type",
+                             [](PyAttribute &self) {
+                               return PyType(self.getContext()->getRef(),
+                                             mlirAttributeGetType(self.attr));
+                             })
       .def(
           "get_named",
           [](PyAttribute &self, std::string name) {
             return PyNamedAttribute(self.attr, std::move(name));
           },
           py::keep_alive<0, 1>(), "Binds a name to the attribute")
       .def("__eq__",
            [](PyAttribute &self, py::object &other) {
py::class_<PyNamedAttribute>(m, "NamedAttribute")
           py::keep_alive<0, 1>(),
           "The underlying generic attribute of the NamedAttribute binding");
 
   // Standard attribute bindings.
   PyFloatAttribute::bind(m);
   PyIntegerAttribute::bind(m);
   PyBoolAttribute::bind(m);
   PyStringAttribute::bind(m);
+  PyDenseElementsAttribute::bind(m);
 
   // Mapping of Type.
   py::class_<PyType>(m, "Type")
       .def_property_readonly(
           "context", [](PyType &self) { return self.getContext().getObject(); },
           "Context that owns the Type")
       .def("__eq__",
            [](PyType &self, py::object &other) {

mlir/lib/CAPI/IR/IR.cpp

 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr) {
   return wrap(mlir::parseAttribute(attr, unwrap(context)));
 }
 
 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
   return wrap(unwrap(attribute).getContext());
 }
 
+MlirType mlirAttributeGetType(MlirAttribute attribute) {
+  return wrap(unwrap(attribute).getType());
+}
+
 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
   return unwrap(a1) == unwrap(a2);
 }
 
 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(attr).print(stream);
   stream.flush();
 }
 
 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
 
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr) {
   return MlirNamedAttribute{name, attr};
 }

mlir/lib/CAPI/IR/StandardAttributes.cpp

 MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
                                                   double element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 
 MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
                                            intptr_t numElements,
-                                           int *elements) {
+                                           const int *elements) {
   SmallVector<bool, 8> values(elements, elements + numElements);
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
 }
 
 /// Creates a dense attribute with elements of the type deduced by templates.
 template <typename T>
 static MlirAttribute getDenseAttribute(MlirType shapedType,
-                                       intptr_t numElements, T *elements) {
+                                       intptr_t numElements,
+                                       const T *elements) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              llvm::makeArrayRef(elements, numElements)));
 }
 
 MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
                                              intptr_t numElements,
-                                             uint32_t *elements) {
+                                             const uint32_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
                                             intptr_t numElements,
-                                            int32_t *elements) {
+                                            const int32_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
                                              intptr_t numElements,
-                                             uint64_t *elements) {
+                                             const uint64_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
                                             intptr_t numElements,
-                                            int64_t *elements) {
+                                            const int64_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
                                             intptr_t numElements,
-                                            float *elements) {
+                                            const float *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
                                              intptr_t numElements,
-                                             double *elements) {
+                                             const double *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 
 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                              intptr_t numElements,
                                              intptr_t *strLengths,
                                              const char **strs) {
   SmallVector<StringRef, 8> values;

mlir/test/Bindings/Python/ir_array_attributes.py

+# RUN: %PYTHON %s | FileCheck %s
+# Note that this is separate from ir_attributes.py since it depends on numpy,
+# and we may want to disable if not available.
+
+import gc
+import mlir
+import numpy as np
+
+def run(f):
+  print("\nTEST:", f.__name__)
+  f()
+  gc.collect()
+  assert mlir.ir.Context._get_live_count() == 0
+
+################################################################################
+# Tests of the array/buffer .get() factory method on unsupported dtype.
+################################################################################
+
+def testGetDenseElementsUnsupported():
+  ctx = mlir.ir.Context()
+  array = np.array([["hello", "goodbye"]])
+  try:
+    attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  except ValueError as e:
+    # CHECK: unimplemented array format conversion from format:
+    print(e)
+
+run(testGetDenseElementsUnsupported)
+
+################################################################################
+# Splats.
+################################################################################
+
+# CHECK-LABEL: TEST: testGetDenseElementsSplatInt
+def testGetDenseElementsSplatInt():
+  ctx = mlir.ir.Context()
+  loc = ctx.get_unknown_location()
+  t = mlir.ir.IntegerType.get_signless(ctx, 32)
+  element = mlir.ir.IntegerAttr.get(t, 555)
+  shaped_type = mlir.ir.RankedTensorType.get((2, 3, 4), t, loc)
+  attr = mlir.ir.DenseElementsAttr.get_splat(shaped_type, element)
+  # CHECK: dense<555> : tensor<2x3x4xi32>
+  print(attr)
+  # CHECK: is_splat: True
+  print("is_splat:", attr.is_splat)
+
+run(testGetDenseElementsSplatInt)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsSplatFloat
+def testGetDenseElementsSplatFloat():
+  ctx = mlir.ir.Context()
+  loc = ctx.get_unknown_location()
+  t = mlir.ir.F32Type.get(ctx)
+  element = mlir.ir.FloatAttr.get(t, 1.2, loc)
+  shaped_type = mlir.ir.RankedTensorType.get((2, 3, 4), t, loc)
+  attr = mlir.ir.DenseElementsAttr.get_splat(shaped_type, element)
+  # CHECK: dense<1.200000e+00> : tensor<2x3x4xf32>
+  print(attr)
+
+run(testGetDenseElementsSplatFloat)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsSplatErrors
+def testGetDenseElementsSplatErrors():
+  ctx = mlir.ir.Context()
+  loc = ctx.get_unknown_location()
+  t = mlir.ir.F32Type.get(ctx)
+  other_t = mlir.ir.F64Type.get(ctx)
+  element = mlir.ir.FloatAttr.get(t, 1.2, loc)
+  other_element = mlir.ir.FloatAttr.get(other_t, 1.2, loc)
+  shaped_type = mlir.ir.RankedTensorType.get((2, 3, 4), t, loc)
+  dynamic_shaped_type = mlir.ir.UnrankedTensorType.get(t, loc)
+  non_shaped_type = t
+
+  try:
+    attr = mlir.ir.DenseElementsAttr.get_splat(non_shaped_type, element)
+  except ValueError as e:
+    # CHECK: Expected a static ShapedType for the shaped_type parameter: Type(f32)
+    print(e)
+
+  try:
+    attr = mlir.ir.DenseElementsAttr.get_splat(dynamic_shaped_type, element)
+  except ValueError as e:
+    # CHECK: Expected a static ShapedType for the shaped_type parameter: Type(tensor<*xf32>)
+    print(e)
+
+  try:
+    attr = mlir.ir.DenseElementsAttr.get_splat(shaped_type, other_element)
+  except ValueError as e:
+    # CHECK: Shaped element type and attribute type must be equal: shaped=Type(tensor<2x3x4xf32>), element=Attribute(1.200000e+00 : f64)
+    print(e)
+
+run(testGetDenseElementsSplatErrors)
+
+
+################################################################################
+# Tests of the array/buffer .get() factory method, in all of its permutations.
+################################################################################
+
+### float and double arrays.
+
+# CHECK-LABEL: TEST: testGetDenseElementsF32
+def testGetDenseElementsF32():
+  ctx = mlir.ir.Context()
+  array = np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]], dtype=np.float32)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1.100000e+00, 2.200000e+00, 3.300000e+00], [4.400000e+00, 5.500000e+00, 6.600000e+00]]> : tensor<2x3xf32>
+  print(attr)
+  # CHECK: is_splat: False
+  print("is_splat:", attr.is_splat)
+
+run(testGetDenseElementsF32)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsF64
+def testGetDenseElementsF64():
+  ctx = mlir.ir.Context()
+  array = np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]], dtype=np.float64)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1.100000e+00, 2.200000e+00, 3.300000e+00], [4.400000e+00, 5.500000e+00, 6.600000e+00]]> : tensor<2x3xf64>
+  print(attr)
+
+run(testGetDenseElementsF64)
+
+
+### 32 bit integer arrays
+# CHECK-LABEL: TEST: testGetDenseElementsI32Signless
+def testGetDenseElementsI32Signless():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
+  print(attr)
+
+run(testGetDenseElementsI32Signless)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsUI32Signless
+def testGetDenseElementsUI32Signless():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint32)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
+  print(attr)
+
+run(testGetDenseElementsUI32Signless)
+
+# CHECK-LABEL: TEST: testGetDenseElementsI32
+def testGetDenseElementsI32():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array, signless=False)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xsi32>
+  print(attr)
+
+run(testGetDenseElementsI32)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsUI32
+def testGetDenseElementsUI32():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint32)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array, signless=False)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xui32>
+  print(attr)
+
+run(testGetDenseElementsUI32)
+
+
+## 64bit integer arrays
+# CHECK-LABEL: TEST: testGetDenseElementsI64Signless
+def testGetDenseElementsI64Signless():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi64>
+  print(attr)
+
+run(testGetDenseElementsI64Signless)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsUI64Signless
+def testGetDenseElementsUI64Signless():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint64)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi64>
+  print(attr)
+
+run(testGetDenseElementsUI64Signless)
+
+# CHECK-LABEL: TEST: testGetDenseElementsI64
+def testGetDenseElementsI64():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array, signless=False)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xsi64>
+  print(attr)
+
+run(testGetDenseElementsI64)
+
+
+# CHECK-LABEL: TEST: testGetDenseElementsUI64
+def testGetDenseElementsUI64():
+  ctx = mlir.ir.Context()
+  array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint64)
+  attr = mlir.ir.DenseElementsAttr.get(ctx, array, signless=False)
+  # CHECK: dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xui64>
+  print(attr)
+
+run(testGetDenseElementsUI64)
+

mlir/test/Bindings/Python/ir_attributes.py

def testFloatAttr():
   fattr = mlir.ir.FloatAttr(ctx.parse_attr("42.0 : f32"))
   # CHECK: fattr value: 42.0
   print("fattr value:", fattr.value)
 
   # Test factory methods.
   loc = ctx.get_unknown_location()
   # CHECK: default_get: 4.200000e+01 : f32
   print("default_get:", mlir.ir.FloatAttr.get(
-      mlir.ir.F32Type(ctx), 42.0, loc))
+      mlir.ir.F32Type.get(ctx), 42.0, loc))
   # CHECK: f32_get: 4.200000e+01 : f32
   print("f32_get:", mlir.ir.FloatAttr.get_f32(ctx, 42.0))
   # CHECK: f64_get: 4.200000e+01 : f64
   print("f64_get:", mlir.ir.FloatAttr.get_f64(ctx, 42.0))
   try:
     fattr_invalid = mlir.ir.FloatAttr.get(
         mlir.ir.IntegerType.get_signless(ctx, 32), 42, loc)
   except ValueError as e:
     # CHECK: invalid 'Type(i32)' and expected floating point type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testFloatAttr)
 
 
 # CHECK-LABEL: TEST: testIntegerAttr
 def testIntegerAttr():
   ctx = mlir.ir.Context()
   iattr = mlir.ir.IntegerAttr(ctx.parse_attr("42"))
   # CHECK: iattr value: 42
   print("iattr value:", iattr.value)
+  # CHECK: iattr type: i64
+  print("iattr type:", iattr.type)
 
   # Test factory methods.
   # CHECK: default_get: 42 : i32
   print("default_get:", mlir.ir.IntegerAttr.get(
       mlir.ir.IntegerType.get_signless(ctx, 32), 42))
 
 run(testIntegerAttr)
 

mlir/test/Bindings/Python/ir_types.py

def testIntegerType():
   print("unsigned:", mlir.ir.IntegerType.get_unsigned(ctx, 64))
 
 run(testIntegerType)
 
 # CHECK-LABEL: TEST: testIndexType
 def testIndexType():
   ctx = mlir.ir.Context()
   # CHECK: index type: index
-  print("index type:", mlir.ir.IndexType(ctx))
+  print("index type:", mlir.ir.IndexType.get(ctx))
 
 run(testIndexType)
 
 # CHECK-LABEL: TEST: testFloatType
 def testFloatType():
   ctx = mlir.ir.Context()
   # CHECK: float: bf16
-  print("float:", mlir.ir.BF16Type(ctx))
+  print("float:", mlir.ir.BF16Type.get(ctx))
   # CHECK: float: f16
-  print("float:", mlir.ir.F16Type(ctx))
+  print("float:", mlir.ir.F16Type.get(ctx))
   # CHECK: float: f32
-  print("float:", mlir.ir.F32Type(ctx))
+  print("float:", mlir.ir.F32Type.get(ctx))
   # CHECK: float: f64
-  print("float:", mlir.ir.F64Type(ctx))
+  print("float:", mlir.ir.F64Type.get(ctx))
 
 run(testFloatType)
 
 # CHECK-LABEL: TEST: testNoneType
 def testNoneType():
   ctx = mlir.ir.Context()
   # CHECK: none type: none
-  print("none type:", mlir.ir.NoneType(ctx))
+  print("none type:", mlir.ir.NoneType.get(ctx))
 
 run(testNoneType)
 
 # CHECK-LABEL: TEST: testComplexType
 def testComplexType():
   ctx = mlir.ir.Context()
   complex_i32 = mlir.ir.ComplexType(ctx.parse_type("complex<i32>"))
   # CHECK: complex type element: i32
   print("complex type element:", complex_i32.element_type)
 
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   # CHECK: complex type: complex<f32>
-  print("complex type:", mlir.ir.ComplexType.get_complex(f32))
+  print("complex type:", mlir.ir.ComplexType.get(f32))
 
-  index = mlir.ir.IndexType(ctx)
+  index = mlir.ir.IndexType.get(ctx)
   try:
-    complex_invalid = mlir.ir.ComplexType.get_complex(index)
+    complex_invalid = mlir.ir.ComplexType.get(index)
   except ValueError as e:
     # CHECK: invalid 'Type(index)' and expected floating point or integer type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testComplexType)
 
def testAbstractShapedType():
   # CHECK: element type: f32
   print("element type:", vector.element_type)
 
 run(testAbstractShapedType)
 
 # CHECK-LABEL: TEST: testVectorType
 def testVectorType():
   ctx = mlir.ir.Context()
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   shape = [2, 3]
   loc = ctx.get_unknown_location()
   # CHECK: vector type: vector<2x3xf32>
-  print("vector type:", mlir.ir.VectorType.get_vector(shape, f32, loc))
+  print("vector type:", mlir.ir.VectorType.get(shape, f32, loc))
 
-  none = mlir.ir.NoneType(ctx)
+  none = mlir.ir.NoneType.get(ctx)
   try:
-    vector_invalid = mlir.ir.VectorType.get_vector(shape, none, loc)
+    vector_invalid = mlir.ir.VectorType.get(shape, none, loc)
   except ValueError as e:
     # CHECK: invalid 'Type(none)' and expected floating point or integer type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testVectorType)
 
 # CHECK-LABEL: TEST: testRankedTensorType
 def testRankedTensorType():
   ctx = mlir.ir.Context()
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   shape = [2, 3]
   loc = ctx.get_unknown_location()
   # CHECK: ranked tensor type: tensor<2x3xf32>
   print("ranked tensor type:",
-        mlir.ir.RankedTensorType.get_ranked_tensor(shape, f32, loc))
+        mlir.ir.RankedTensorType.get(shape, f32, loc))
 
-  none = mlir.ir.NoneType(ctx)
+  none = mlir.ir.NoneType.get(ctx)
   try:
-    tensor_invalid = mlir.ir.RankedTensorType.get_ranked_tensor(shape, none,
-                                                                loc)
+    tensor_invalid = mlir.ir.RankedTensorType.get(shape, none, loc)
   except ValueError as e:
     # CHECK: invalid 'Type(none)' and expected floating point, integer, vector
     # CHECK: or complex type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testRankedTensorType)
 
 # CHECK-LABEL: TEST: testUnrankedTensorType
 def testUnrankedTensorType():
   ctx = mlir.ir.Context()
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   loc = ctx.get_unknown_location()
-  unranked_tensor = mlir.ir.UnrankedTensorType.get_unranked_tensor(f32, loc)
+  unranked_tensor = mlir.ir.UnrankedTensorType.get(f32, loc)
   # CHECK: unranked tensor type: tensor<*xf32>
   print("unranked tensor type:", unranked_tensor)
   try:
     invalid_rank = unranked_tensor.rank
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
   try:
     invalid_is_dynamic_dim = unranked_tensor.is_dynamic_dim(0)
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
   try:
     invalid_get_dim_size = unranked_tensor.get_dim_size(1)
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
 
-  none = mlir.ir.NoneType(ctx)
+  none = mlir.ir.NoneType.get(ctx)
   try:
-    tensor_invalid = mlir.ir.UnrankedTensorType.get_unranked_tensor(none, loc)
+    tensor_invalid = mlir.ir.UnrankedTensorType.get(none, loc)
   except ValueError as e:
     # CHECK: invalid 'Type(none)' and expected floating point, integer, vector
     # CHECK: or complex type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testUnrankedTensorType)
 
 # CHECK-LABEL: TEST: testMemRefType
 def testMemRefType():
   ctx = mlir.ir.Context()
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   shape = [2, 3]
   loc = ctx.get_unknown_location()
   memref = mlir.ir.MemRefType.get_contiguous_memref(f32, shape, 2, loc)
   # CHECK: memref type: memref<2x3xf32, 2>
   print("memref type:", memref)
   # CHECK: number of affine layout maps: 0
   print("number of affine layout maps:", memref.num_affine_maps)
   # CHECK: memory space: 2
   print("memory space:", memref.memory_space)
 
-  none = mlir.ir.NoneType(ctx)
+  none = mlir.ir.NoneType.get(ctx)
   try:
     memref_invalid = mlir.ir.MemRefType.get_contiguous_memref(none, shape, 2,
                                                               loc)
   except ValueError as e:
     # CHECK: invalid 'Type(none)' and expected floating point, integer, vector
     # CHECK: or complex type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testMemRefType)
 
 # CHECK-LABEL: TEST: testUnrankedMemRefType
 def testUnrankedMemRefType():
   ctx = mlir.ir.Context()
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   loc = ctx.get_unknown_location()
-  unranked_memref = mlir.ir.UnrankedMemRefType.get_unranked_memref(f32, 2, loc)
+  unranked_memref = mlir.ir.UnrankedMemRefType.get(f32, 2, loc)
   # CHECK: unranked memref type: memref<*xf32, 2>
   print("unranked memref type:", unranked_memref)
   try:
     invalid_rank = unranked_memref.rank
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
   try:
     invalid_is_dynamic_dim = unranked_memref.is_dynamic_dim(0)
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
   try:
     invalid_get_dim_size = unranked_memref.get_dim_size(1)
   except ValueError as e:
     # CHECK: calling this method requires that the type has a rank.
     print(e)
   else:
     print("Exception not produced")
 
-  none = mlir.ir.NoneType(ctx)
+  none = mlir.ir.NoneType.get(ctx)
   try:
-    memref_invalid = mlir.ir.UnrankedMemRefType.get_unranked_memref(none, 2,
-                                                                    loc)
+    memref_invalid = mlir.ir.UnrankedMemRefType.get(none, 2, loc)
   except ValueError as e:
     # CHECK: invalid 'Type(none)' and expected floating point, integer, vector
     # CHECK: or complex type.
     print(e)
   else:
     print("Exception not produced")
 
 run(testUnrankedMemRefType)
 
 # CHECK-LABEL: TEST: testTupleType
 def testTupleType():
   ctx = mlir.ir.Context()
   i32 = mlir.ir.IntegerType(ctx.parse_type("i32"))
-  f32 = mlir.ir.F32Type(ctx)
+  f32 = mlir.ir.F32Type.get(ctx)
   vector = mlir.ir.VectorType(ctx.parse_type("vector<2x3xf32>"))
   l = [i32, f32, vector]
   tuple_type = mlir.ir.TupleType.get_tuple(ctx, l)
   # CHECK: tuple type: tuple<i32, f32, vector<2x3xf32>>
   print("tuple type:", tuple_type)
   # CHECK: number of types: 3
   print("number of types:", tuple_type.num_types)
   # CHECK: pos-th type in the tuple type: f32
   print("pos-th type in the tuple type:", tuple_type.get_type(1))
 
 run(testTupleType)
 
 
 # CHECK-LABEL: TEST: testFunctionType
 def testFunctionType():
   ctx = mlir.ir.Context()
   input_types = [mlir.ir.IntegerType.get_signless(ctx, 32),
                  mlir.ir.IntegerType.get_signless(ctx, 16)]
-  result_types = [mlir.ir.IndexType(ctx)]
+  result_types = [mlir.ir.IndexType.get(ctx)]
   func = mlir.ir.FunctionType.get(ctx, input_types, result_types)
   # CHECK: INPUTS: [Type(i32), Type(i16)]
   print("INPUTS:", func.inputs)
   # CHECK: RESULTS: [Type(index)]
   print("RESULTS:", func.results)
 
 
 run(testFunctionType)

mlir/test/CAPI/ir.c

 int printStandardAttributes(MlirContext ctx) {
   MlirAttribute floating =
       mlirFloatAttrDoubleGet(ctx, mlirF64TypeGet(ctx), 2.0);
   if (!mlirAttributeIsAFloat(floating) ||
       fabs(mlirFloatAttrGetValueDouble(floating) - 2.0) > 1E-6)
     return 1;
   mlirAttributeDump(floating);
 
+  // Exercise mlirAttributeGetType() just for the first one.
+  MlirType floatingType = mlirAttributeGetType(floating);
+  mlirTypeDump(floatingType);
+
   MlirAttribute integer = mlirIntegerAttrGet(mlirIntegerTypeGet(ctx, 32), 42);
   if (!mlirAttributeIsAInteger(integer) ||
       mlirIntegerAttrGetValueInt(integer) != 42)
     return 2;
   mlirAttributeDump(integer);
 
   MlirAttribute boolean = mlirBoolAttrGet(ctx, 1);
   if (!mlirAttributeIsABool(boolean) || !mlirBoolAttrGetValue(boolean))
int main() {
   // clang-format on
   fprintf(stderr, "@types\n");
   int errcode = printStandardTypes(ctx);
   fprintf(stderr, "%d\n", errcode);
 
   // clang-format off
   // CHECK-LABEL: @attrs
   // CHECK: 2.000000e+00 : f64
+  // CHECK: f64
   // CHECK: 42 : i32
   // CHECK: true
   // CHECK: #std.abc
   // CHECK: "de"
   // CHECK: @fgh
   // CHECK: @ij::@fgh::@fgh
   // CHECK: f32
   // CHECK: unit