[mlir][CAPI] Add mlirAttributeGetType function.

[stellaraccident]

Summary

• Also fixes the const-ness of the various DenseElementsAttr construction functions.
• Both issues identified when trying to use the DenseElementsAttr functions.

[stellaraccident]

Rebase

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_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