[MLIR][python bindings] Add casting of concrete types when returning from bindings code

[makslevental]

Summary

abandoned in favor of D150927

This diff adds casting of MlirType to an instance of PyConcreteType<> (when possible) for returns from cpp. Note, only returns. Such casting greatly improves the APIs as the user then doesn't need to cast/wrap in Python. For example VectorType(Type.parse("vector<2x3xf32>")) becomes just Type.parse("vector<2x3xf32>").

More importantly, PyValue.type now returns a concrete type (when possible); e.g.,

cst = arith.ConstantOp(F32Type.get(), 0.0).result
print(type(cst.type).__name__)
print(repr(cst.type))

prints

F32Type
F32Type(f32)

Attributes as well:

attr = DenseElementsAttr(Attribute.parse("dense<123> : tensor<i16>"))
print(repr(attr.type))
print(repr(attr.type.element_type))

prints

RankedTensorType(tensor<i16>)
IntegerType(i16)

This paves the way for writing code (both cpp and Python) that is "type conscious" (see this draft).

One current limitation is that mlir_type_subclass can't participate but I think I can make that work too (in a follow-up diff).

[makslevental]

refactor switch into IRTypes.h

[makslevental]

order correctly the macro and add tensor tests

[makslevental]

nit re unranked type

[makslevental]

handle element_type for containers

[makslevental]

handle typed attr

[makslevental]

clean up tests

[makslevental]

add complex type and factor tests again

[makslevental]

add tuple type

[makslevental]

add function type

[makslevental]

mlir/test/python/ir/builtin_types.py

592–594

There's a juicy bug lurking here: if you don't insert into a region for this op (e.g., either func or module) you will get an assert fail at the end of the script:

error: 'arith.constant' op operation destroyed but still has uses
LLVM ERROR: operation destroyed but still has uses

If you dump the op after creation you get

%0 = "tensor.from_elements"(<<UNKNOWN SSA VALUE>>) : (f32) -> tensor<*xf32>

So the op is built successfully and "uses" c0 but the bindings aren't aware (I guess liveOperations is skipping a beat somehow). Note, <<UNKNOWN SSA VALUE>> is because there's no enclosing region, not because it's actually a null SSA value (I should've made that print <<UNATTACHED SSA VALUE>>...)

[makslevental]

rewrite macro

[makslevental]

rewrite macro

[makslevental]

mlir/lib/Bindings/Python/IRModule.h

1188–1206 ↗

(On Diff #521797)

Someone with better macro-fu might be able to suggest a prettier/smarter way to do this...

[makslevental]

rename macro

[makslevental]

add comment

[rkayaith]

mlir/lib/Bindings/Python/IRModule.h

1148 ↗

(On Diff #521802)

I think we'd really want something that works for downstream types too. Have you looked at how the opview downcasting works? There's an op name -> python class mapping maintained, and I imagine that could be generalized to a typeid -> python class map to work with attributes and types as well.

[makslevental]

mlir/lib/Bindings/Python/IRModule.h

1148 ↗

(On Diff #521802)

that could be generalized to a typeid -> python class map

Can it? Can you stick typeids into a map? Hmmm digging around I see

/// Checks if two types are equal.
MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2);

which is enough for std::unordered_map (and the like) I think.

But you would need "sentinel" instances of the types to play the role of keys? Alternatively maybe you mean literally the integer? I'm pretty laissez faire so I support that but what do other people think? But these would be fully-refined right? So tensor<1x1xf32> and tensor<1x2xf32> wouldn't have the same typeid and therefore wouldn't produce a hit.

But there's another way that's possible, that I planned for the follow up, which is to jus add a case in the type_caster that queries a map that's mlir_type_subclass.__name__ -> mlir_type_subclass. Putting it before or after the builtin types (so the match happens early) can be debated.

The only issue is the case matching overhead but how bad could it be (famous last words...). This is probably totally wild but I could write a multithreaded match ("try all mlirTypeIsA##CONCRETETYPE functions and first one wins") but that's probably overengineering.

[makslevental]

mlir/lib/Bindings/Python/IRModule.h

1148 ↗

(On Diff #521802)

Yea I just double check the typeid thing won't work:

ten.type
>>> Type(tensor<10x10xi32>)
twenty.type
>>> Type(tensor<20x20xi32>)
ten.type == twenty.type
>>> False

[rkayaith]

mlir/lib/Bindings/Python/IRModule.h

1148 ↗

(On Diff #521802)

By typeid I mean this guy: https://mlir.llvm.org/doxygen/classmlir_1_1Type.html#accf7dade447f73f5b04c46fcf616b68c

I don't think any of that is exposed through the bindings yet though

[makslevental]

mlir/lib/Bindings/Python/IRModule.h

1148 ↗

(On Diff #521802)

Oh you're right - I was conflating the types themselves with typeids. Okay cool I'll send up another PR that exposes the necessary things and then adjust this one.

mlir/lib/Bindings/Python/IRCore.cpp

 //===- IRModules.cpp - IR Submodules of pybind module ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IRModule.h"
 
 #include "Globals.h"
+#include "IRTypes.h"
 #include "PybindUtils.h"
 
 #include "mlir-c/Bindings/Python/Interop.h"
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir-c/Debug.h"
 #include "mlir-c/Diagnostics.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
py::class_<PyValue>(m, "Value", py::module_local())
             if (useLocalScope)
               mlirOpPrintingFlagsUseLocalScope(flags);
             mlirValuePrintAsOperand(self.get(), flags, printAccum.getCallback(),
                                     printAccum.getUserData());
             mlirOpPrintingFlagsDestroy(flags);
             return printAccum.join();
           },
           py::arg("use_local_scope") = false, kGetNameAsOperand)
-      .def_property_readonly("type",
-                             [](PyValue &self) {
-                               return PyType(
-                                   self.getParentOperation()->getContext(),
-                                   mlirValueGetType(self.get()));
-                             })
+      .def_property_readonly(
+          "type", [](PyValue &self) { return mlirValueGetType(self.get()); })
       .def(
           "replace_all_uses_with",
           [](PyValue &self, PyValue &with) {
             mlirValueReplaceAllUsesOfWith(self.get(), with.get());
           },
           kValueReplaceAllUsesWithDocstring);
   PyBlockArgument::bind(m);
   PyOpResult::bind(m);

mlir/lib/Bindings/Python/IRTypes.h

+//===- IRTypes.h - IR types of pybind module -----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_BINDINGS_PYTHON_IRTYPES_H
+#define MLIR_BINDINGS_PYTHON_IRTYPES_H
+
+#include "IRModule.h"
+#include "mlir-c/Bindings/Python/Interop.h"
+#include "mlir-c/BuiltinTypes.h"
+#include "mlir-c/IR.h"
+#include <pybind11/pybind11.h>
+
+using namespace mlir;
+using namespace mlir::python;
+
+namespace mlir {
+namespace python {
+class PyIntegerType : public PyConcreteType<PyIntegerType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAInteger;
+  static constexpr const char *pyClassName = "IntegerType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// 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);
+};
+
+/// Floating Point Type subclass - Float8E4M3FNType.
+class PyFloat8E4M3FNType : public PyConcreteType<PyFloat8E4M3FNType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3FN;
+  static constexpr const char *pyClassName = "Float8E4M3FNType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Floating Point Type subclass - Float8M5E2Type.
+class PyFloat8E5M2Type : public PyConcreteType<PyFloat8E5M2Type> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E5M2;
+  static constexpr const char *pyClassName = "Float8E5M2Type";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Floating Point Type subclass - Float8E4M3FNUZ.
+class PyFloat8E4M3FNUZType : public PyConcreteType<PyFloat8E4M3FNUZType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3FNUZ;
+  static constexpr const char *pyClassName = "Float8E4M3FNUZType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Floating Point Type subclass - Float8E4M3B11FNUZ.
+class PyFloat8E4M3B11FNUZType : public PyConcreteType<PyFloat8E4M3B11FNUZType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3B11FNUZ;
+  static constexpr const char *pyClassName = "Float8E4M3B11FNUZType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Floating Point Type subclass - Float8E5M2FNUZ.
+class PyFloat8E5M2FNUZType : public PyConcreteType<PyFloat8E5M2FNUZType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E5M2FNUZ;
+  static constexpr const char *pyClassName = "Float8E5M2FNUZType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// 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);
+};
+
+/// 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);
+};
+
+/// 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);
+};
+
+/// 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);
+};
+
+/// 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);
+};
+
+/// 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);
+};
+
+class PyShapedType : public PyConcreteType<PyShapedType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAShaped;
+  static constexpr const char *pyClassName = "ShapedType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+
+private:
+  void requireHasRank();
+};
+
+/// Vector Type subclass - VectorType.
+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);
+};
+
+/// Ranked Tensor Type subclass - RankedTensorType.
+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);
+};
+
+/// Unranked Tensor Type subclass - UnrankedTensorType.
+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);
+};
+
+/// Ranked MemRef Type subclass - MemRefType.
+class PyMemRefType : public PyConcreteType<PyMemRefType, PyShapedType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAMemRef;
+  static constexpr const char *pyClassName = "MemRefType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Unranked MemRef Type subclass - UnrankedMemRefType.
+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);
+};
+
+/// Tuple Type subclass - TupleType.
+class PyTupleType : public PyConcreteType<PyTupleType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsATuple;
+  static constexpr const char *pyClassName = "TupleType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Function type.
+class PyFunctionType : public PyConcreteType<PyFunctionType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFunction;
+  static constexpr const char *pyClassName = "FunctionType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+/// Opaque Type subclass - OpaqueType.
+class PyOpaqueType : public PyConcreteType<PyOpaqueType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAOpaque;
+  static constexpr const char *pyClassName = "OpaqueType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c);
+};
+
+#define FORALL_CONCRETE_TYPES(_)                                               \
+  _(BF16)                                                                      \
+  _(Complex)                                                                   \
+  _(F16)                                                                       \
+  _(F32)                                                                       \
+  _(F64)                                                                       \
+  _(Float8E4M3B11FNUZ)                                                         \
+  _(Float8E4M3FN)                                                              \
+  _(Float8E4M3FNUZ)                                                            \
+  _(Float8E5M2)                                                                \
+  _(Float8E5M2FNUZ)                                                            \
+  _(Function)                                                                  \
+  _(Index)                                                                     \
+  _(Integer)                                                                   \
+  _(MemRef)                                                                    \
+  _(None)                                                                      \
+  _(Opaque)                                                                    \
+  _(RankedTensor)                                                              \
+  _(Shaped)                                                                    \
+  _(Tuple)                                                                     \
+  _(UnrankedMemRef)                                                            \
+  _(UnrankedTensor)                                                            \
+  _(Vector)
+
+} // namespace python
+} // namespace mlir
+
+#include <iostream>
+
+namespace pybind11 {
+namespace detail {
+
+/// Casts MlirType that matches one of the concretes above <-> ConcreteType.
+template <>
+struct type_caster<MlirType> {
+  PYBIND11_TYPE_CASTER(MlirType, _("MlirType"));
+  static handle cast(MlirType t, return_value_policy, handle) {
+    PyMlirContextRef context = PyMlirContext::forContext(mlirTypeGetContext(t));
+
+#define DEFINE_SUBCLASS(TTT)                                                   \
+  if (Py##TTT##Type::isaFunction(t))                                           \
+    return pybind11::cast(Py##TTT##Type(context, t)).release();
+    FORALL_CONCRETE_TYPES(DEFINE_SUBCLASS)
+#undef DEFINE_SUBCLASS
+
+    object capsule = reinterpret_steal<object>(mlirPythonTypeToCapsule(t));
+    return module::import(MAKE_MLIR_PYTHON_QUALNAME("ir"))
+        .attr("Type")
+        .attr(MLIR_PYTHON_CAPI_FACTORY_ATTR)(capsule)
+        .release();
+  }
+};
+
+} // namespace detail
+} // namespace pybind11
+
+#endif
 No newline at end of file

mlir/lib/Bindings/Python/IRTypes.cpp

 //===- IRTypes.cpp - Exports builtin and standard types -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "IRTypes.h"
 #include "IRModule.h"
 
 #include "PybindUtils.h"
 
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir-c/BuiltinTypes.h"
 #include <optional>
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
 using llvm::SmallVector;
 using llvm::Twine;
 
 namespace {
 
 /// Checks whether the given type is an integer or float type.
 static int mlirTypeIsAIntegerOrFloat(MlirType type) {
   return mlirTypeIsAInteger(type) || mlirTypeIsABF16(type) ||
          mlirTypeIsAF16(type) || mlirTypeIsAF32(type) || mlirTypeIsAF64(type);
 }
 
-class PyIntegerType : public PyConcreteType<PyIntegerType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAInteger;
-  static constexpr const char *pyClassName = "IntegerType";
-  using PyConcreteType::PyConcreteType;
+static MlirStringRef toMlirStringRef(const std::string &s) {
+  return mlirStringRefCreate(s.data(), s.size());
+}
+
+} // namespace
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get_signless",
-        [](unsigned width, DefaultingPyMlirContext context) {
-          MlirType t = mlirIntegerTypeGet(context->get(), width);
-          return PyIntegerType(context->getRef(), t);
-        },
-        py::arg("width"), py::arg("context") = py::none(),
-        "Create a signless integer type");
-    c.def_static(
-        "get_signed",
-        [](unsigned width, DefaultingPyMlirContext context) {
-          MlirType t = mlirIntegerTypeSignedGet(context->get(), width);
-          return PyIntegerType(context->getRef(), t);
-        },
-        py::arg("width"), py::arg("context") = py::none(),
-        "Create a signed integer type");
-    c.def_static(
-        "get_unsigned",
-        [](unsigned width, DefaultingPyMlirContext context) {
-          MlirType t = mlirIntegerTypeUnsignedGet(context->get(), width);
-          return PyIntegerType(context->getRef(), t);
-        },
-        py::arg("width"), py::arg("context") = py::none(),
-        "Create an unsigned integer type");
-    c.def_property_readonly(
-        "width",
-        [](PyIntegerType &self) { return mlirIntegerTypeGetWidth(self); },
-        "Returns the width of the integer type");
-    c.def_property_readonly(
-        "is_signless",
-        [](PyIntegerType &self) -> bool {
-          return mlirIntegerTypeIsSignless(self);
-        },
-        "Returns whether this is a signless integer");
-    c.def_property_readonly(
-        "is_signed",
-        [](PyIntegerType &self) -> bool {
-          return mlirIntegerTypeIsSigned(self);
-        },
-        "Returns whether this is a signed integer");
-    c.def_property_readonly(
-        "is_unsigned",
-        [](PyIntegerType &self) -> bool {
-          return mlirIntegerTypeIsUnsigned(self);
-        },
-        "Returns whether this is an unsigned integer");
-  }
-};
+namespace mlir::python {
+
+void PyIntegerType::bindDerived(ClassTy &c) {
+      [](PyIntegerType &self) -> bool { return mlirIntegerTypeIsSigned(self); },
 
-/// 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_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirIndexTypeGet(context->get());
-          return PyIndexType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a index type.");
-  }
-};
-
-/// Floating Point Type subclass - Float8E4M3FNType.
-class PyFloat8E4M3FNType : public PyConcreteType<PyFloat8E4M3FNType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3FN;
-  static constexpr const char *pyClassName = "Float8E4M3FNType";
-  using PyConcreteType::PyConcreteType;
+void PyIndexType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirFloat8E4M3FNTypeGet(context->get());
-          return PyFloat8E4M3FNType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a float8_e4m3fn type.");
-  }
-};
+void PyFloat8E4M3FNType::bindDerived(ClassTy &c) {
 
-/// Floating Point Type subclass - Float8M5E2Type.
-class PyFloat8E5M2Type : public PyConcreteType<PyFloat8E5M2Type> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E5M2;
-  static constexpr const char *pyClassName = "Float8E5M2Type";
-  using PyConcreteType::PyConcreteType;
-
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirFloat8E5M2TypeGet(context->get());
-          return PyFloat8E5M2Type(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a float8_e5m2 type.");
-  }
-};
-
-/// Floating Point Type subclass - Float8E4M3FNUZ.
-class PyFloat8E4M3FNUZType : public PyConcreteType<PyFloat8E4M3FNUZType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3FNUZ;
-  static constexpr const char *pyClassName = "Float8E4M3FNUZType";
-  using PyConcreteType::PyConcreteType;
+void PyFloat8E5M2Type::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirFloat8E4M3FNUZTypeGet(context->get());
-          return PyFloat8E4M3FNUZType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a float8_e4m3fnuz type.");
-  }
-};
-
-/// Floating Point Type subclass - Float8E4M3B11FNUZ.
-class PyFloat8E4M3B11FNUZType : public PyConcreteType<PyFloat8E4M3B11FNUZType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E4M3B11FNUZ;
-  static constexpr const char *pyClassName = "Float8E4M3B11FNUZType";
-  using PyConcreteType::PyConcreteType;
+void PyFloat8E4M3FNUZType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirFloat8E4M3B11FNUZTypeGet(context->get());
-          return PyFloat8E4M3B11FNUZType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a float8_e4m3b11fnuz type.");
-  }
-};
+void PyFloat8E4M3B11FNUZType::bindDerived(ClassTy &c) {
 
-/// Floating Point Type subclass - Float8E5M2FNUZ.
-class PyFloat8E5M2FNUZType : public PyConcreteType<PyFloat8E5M2FNUZType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFloat8E5M2FNUZ;
-  static constexpr const char *pyClassName = "Float8E5M2FNUZType";
-  using PyConcreteType::PyConcreteType;
-
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirFloat8E5M2FNUZTypeGet(context->get());
-          return PyFloat8E5M2FNUZType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a float8_e5m2fnuz type.");
-  }
-};
-
-/// 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;
+void PyFloat8E5M2FNUZType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirBF16TypeGet(context->get());
-          return PyBF16Type(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a bf16 type.");
-  }
-};
+void PyBF16Type::bindDerived(ClassTy &c) {
 
-/// 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_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirF16TypeGet(context->get());
-          return PyF16Type(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a f16 type.");
-  }
-};
-
-/// 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;
+void PyF16Type::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirF32TypeGet(context->get());
-          return PyF32Type(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a f32 type.");
-  }
-};
+void PyF32Type::bindDerived(ClassTy &c) {
 
-/// 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_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirF64TypeGet(context->get());
-          return PyF64Type(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a f64 type.");
-  }
-};
-
-/// None Type subclass - NoneType.
-class PyNoneType : public PyConcreteType<PyNoneType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsANone;
-  static constexpr const char *pyClassName = "NoneType";
-  using PyConcreteType::PyConcreteType;
+void PyF64Type::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](DefaultingPyMlirContext context) {
-          MlirType t = mlirNoneTypeGet(context->get());
-          return PyNoneType(context->getRef(), t);
-        },
-        py::arg("context") = py::none(), "Create a none type.");
-  }
-};
+void PyNoneType::bindDerived(ClassTy &c) {
 
-/// 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",
-        [](PyType &elementType) {
-          // The element must be a floating point or integer scalar type.
-          if (mlirTypeIsAIntegerOrFloat(elementType)) {
-            MlirType t = mlirComplexTypeGet(elementType);
-            return PyComplexType(elementType.getContext(), t);
-          }
-          throw SetPyError(
-              PyExc_ValueError,
-              Twine("invalid '") +
-                  py::repr(py::cast(elementType)).cast<std::string>() +
-                  "' and expected floating point or integer type.");
-        },
-        "Create a complex type");
-    c.def_property_readonly(
-        "element_type",
-        [](PyComplexType &self) -> PyType {
-          MlirType t = mlirComplexTypeGetElementType(self);
-          return PyType(self.getContext(), t);
-        },
-        "Returns element type.");
-  }
-};
-
-class PyShapedType : public PyConcreteType<PyShapedType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAShaped;
-  static constexpr const char *pyClassName = "ShapedType";
-  using PyConcreteType::PyConcreteType;
+void PyComplexType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_property_readonly(
-        "element_type",
-        [](PyShapedType &self) {
-          MlirType t = mlirShapedTypeGetElementType(self);
-          return PyType(self.getContext(), t);
-        },
-        "Returns the element type of the shaped type.");
-    c.def_property_readonly(
-        "has_rank",
-        [](PyShapedType &self) -> bool { return mlirShapedTypeHasRank(self); },
-        "Returns whether the given shaped type is ranked.");
-    c.def_property_readonly(
-        "rank",
-        [](PyShapedType &self) {
-          self.requireHasRank();
-          return mlirShapedTypeGetRank(self);
-        },
-        "Returns the rank of the given ranked shaped type.");
-    c.def_property_readonly(
-        "has_static_shape",
-        [](PyShapedType &self) -> bool {
-          return mlirShapedTypeHasStaticShape(self);
-        },
-        "Returns whether the given shaped type has a static shape.");
-    c.def(
-        "is_dynamic_dim",
-        [](PyShapedType &self, intptr_t dim) -> bool {
-          self.requireHasRank();
-          return mlirShapedTypeIsDynamicDim(self, dim);
-        },
-        py::arg("dim"),
-        "Returns whether the dim-th dimension of the given shaped type is "
-        "dynamic.");
-    c.def(
-        "get_dim_size",
-        [](PyShapedType &self, intptr_t dim) {
-          self.requireHasRank();
-          return mlirShapedTypeGetDimSize(self, dim);
-        },
-        py::arg("dim"),
-        "Returns the dim-th dimension of the given ranked shaped type.");
-    c.def_static(
-        "is_dynamic_size",
-        [](int64_t size) -> bool { return mlirShapedTypeIsDynamicSize(size); },
-        py::arg("dim_size"),
-        "Returns whether the given dimension size indicates a dynamic "
-        "dimension.");
-    c.def(
-        "is_dynamic_stride_or_offset",
-        [](PyShapedType &self, int64_t val) -> bool {
-          self.requireHasRank();
-          return mlirShapedTypeIsDynamicStrideOrOffset(val);
-        },
-        py::arg("dim_size"),
-        "Returns whether the given value is used as a placeholder for dynamic "
-        "strides and offsets in shaped types.");
-    c.def_property_readonly(
-        "shape",
-        [](PyShapedType &self) {
-          self.requireHasRank();
+void PyShapedType::bindDerived(ClassTy &c) {
 
-          std::vector<int64_t> shape;
-          int64_t rank = mlirShapedTypeGetRank(self);
-          shape.reserve(rank);
-          for (int64_t i = 0; i < rank; ++i)
-            shape.push_back(mlirShapedTypeGetDimSize(self, i));
-          return shape;
-        },
-        "Returns the shape of the ranked shaped type as a list of integers.");
-    c.def_static(
-        "get_dynamic_size", []() { return mlirShapedTypeGetDynamicSize(); },
-        "Returns the value used to indicate dynamic dimensions in shaped "
-        "types.");
-    c.def_static(
-        "get_dynamic_stride_or_offset",
-        []() { return mlirShapedTypeGetDynamicStrideOrOffset(); },
-        "Returns the value used to indicate dynamic strides or offsets in "
-        "shaped types.");
-  }
 
-private:
-  void requireHasRank() {
-    if (!mlirShapedTypeHasRank(*this)) {
-      throw SetPyError(
-          PyExc_ValueError,
+void PyShapedType::requireHasRank() {
+    throw SetPyError(PyExc_ValueError,
                      "calling this method requires that the type has a rank.");
-    }
-  }
-};
-
-/// Vector Type subclass - VectorType.
-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",
-        [](std::vector<int64_t> shape, PyType &elementType,
-           DefaultingPyLocation loc) {
-          PyMlirContext::ErrorCapture errors(loc->getContext());
-          MlirType t = mlirVectorTypeGetChecked(loc, shape.size(), shape.data(),
-                                                elementType);
-          if (mlirTypeIsNull(t))
-            throw MLIRError("Invalid type", errors.take());
-          return PyVectorType(elementType.getContext(), t);
-        },
-        py::arg("shape"), py::arg("elementType"), py::arg("loc") = py::none(),
-        "Create a vector type");
-  }
-};
+void PyVectorType::bindDerived(ClassTy &c) {
 
-/// Ranked Tensor Type subclass - RankedTensorType.
-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",
-        [](std::vector<int64_t> shape, PyType &elementType,
-           std::optional<PyAttribute> &encodingAttr, DefaultingPyLocation loc) {
-          PyMlirContext::ErrorCapture errors(loc->getContext());
-          MlirType t = mlirRankedTensorTypeGetChecked(
-              loc, shape.size(), shape.data(), elementType,
-              encodingAttr ? encodingAttr->get() : mlirAttributeGetNull());
-          if (mlirTypeIsNull(t))
-            throw MLIRError("Invalid type", errors.take());
-          return PyRankedTensorType(elementType.getContext(), t);
-        },
-        py::arg("shape"), py::arg("element_type"),
-        py::arg("encoding") = py::none(), py::arg("loc") = py::none(),
-        "Create a ranked tensor type");
-    c.def_property_readonly(
-        "encoding", [](PyRankedTensorType &self) -> std::optional<PyAttribute> {
-          MlirAttribute encoding = mlirRankedTensorTypeGetEncoding(self.get());
-          if (mlirAttributeIsNull(encoding))
-            return std::nullopt;
-          return PyAttribute(self.getContext(), encoding);
-        });
-  }
-};
-
-/// Unranked Tensor Type subclass - UnrankedTensorType.
-class PyUnrankedTensorType
-    : public PyConcreteType<PyUnrankedTensorType, PyShapedType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAUnrankedTensor;
-  static constexpr const char *pyClassName = "UnrankedTensorType";
-  using PyConcreteType::PyConcreteType;
+void PyRankedTensorType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](PyType &elementType, DefaultingPyLocation loc) {
-          PyMlirContext::ErrorCapture errors(loc->getContext());
-          MlirType t = mlirUnrankedTensorTypeGetChecked(loc, elementType);
-          if (mlirTypeIsNull(t))
-            throw MLIRError("Invalid type", errors.take());
-          return PyUnrankedTensorType(elementType.getContext(), t);
-        },
-        py::arg("element_type"), py::arg("loc") = py::none(),
-        "Create a unranked tensor type");
-  }
-};
-
-/// Ranked MemRef Type subclass - MemRefType.
-class PyMemRefType : public PyConcreteType<PyMemRefType, PyShapedType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAMemRef;
-  static constexpr const char *pyClassName = "MemRefType";
-  using PyConcreteType::PyConcreteType;
+void PyUnrankedTensorType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-         "get",
-         [](std::vector<int64_t> shape, PyType &elementType,
-            PyAttribute *layout, PyAttribute *memorySpace,
-            DefaultingPyLocation loc) {
-           PyMlirContext::ErrorCapture errors(loc->getContext());
-           MlirAttribute layoutAttr = layout ? *layout : mlirAttributeGetNull();
-           MlirAttribute memSpaceAttr =
-               memorySpace ? *memorySpace : mlirAttributeGetNull();
-           MlirType t =
-               mlirMemRefTypeGetChecked(loc, elementType, shape.size(),
-                                        shape.data(), layoutAttr, memSpaceAttr);
-           if (mlirTypeIsNull(t))
-             throw MLIRError("Invalid type", errors.take());
-           return PyMemRefType(elementType.getContext(), t);
-         },
-         py::arg("shape"), py::arg("element_type"),
-         py::arg("layout") = py::none(), py::arg("memory_space") = py::none(),
-         py::arg("loc") = py::none(), "Create a memref type")
-        .def_property_readonly(
-            "layout",
-            [](PyMemRefType &self) -> PyAttribute {
-              MlirAttribute layout = mlirMemRefTypeGetLayout(self);
-              return PyAttribute(self.getContext(), layout);
-            },
-            "The layout of the MemRef type.")
-        .def_property_readonly(
-            "affine_map",
-            [](PyMemRefType &self) -> PyAffineMap {
-              MlirAffineMap map = mlirMemRefTypeGetAffineMap(self);
-              return PyAffineMap(self.getContext(), map);
-            },
-            "The layout of the MemRef type as an affine map.")
-        .def_property_readonly(
-            "memory_space",
-            [](PyMemRefType &self) -> PyAttribute {
-              MlirAttribute a = mlirMemRefTypeGetMemorySpace(self);
-              return PyAttribute(self.getContext(), a);
-            },
-            "Returns the memory space of the given MemRef type.");
-  }
-};
+void PyMemRefType::bindDerived(ClassTy &c) {
+       [](std::vector<int64_t> shape, PyType &elementType, PyAttribute *layout,
+          PyAttribute *memorySpace, DefaultingPyLocation loc) {
 
-/// Unranked MemRef Type subclass - UnrankedMemRefType.
-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",
-         [](PyType &elementType, PyAttribute *memorySpace,
-            DefaultingPyLocation loc) {
-           PyMlirContext::ErrorCapture errors(loc->getContext());
-           MlirAttribute memSpaceAttr = {};
-           if (memorySpace)
-             memSpaceAttr = *memorySpace;
+void PyUnrankedMemRefType::bindDerived(ClassTy &c) {
 
-           MlirType t =
-               mlirUnrankedMemRefTypeGetChecked(loc, elementType, memSpaceAttr);
-           if (mlirTypeIsNull(t))
-             throw MLIRError("Invalid type", errors.take());
-           return PyUnrankedMemRefType(elementType.getContext(), t);
-         },
-         py::arg("element_type"), py::arg("memory_space"),
-         py::arg("loc") = py::none(), "Create a unranked memref type")
-        .def_property_readonly(
-            "memory_space",
-            [](PyUnrankedMemRefType &self) -> PyAttribute {
-              MlirAttribute a = mlirMemRefTypeGetMemorySpace(self);
-              return PyAttribute(self.getContext(), a);
-            },
-            "Returns the memory space of the given Unranked MemRef type.");
-  }
-};
-
-/// Tuple Type subclass - TupleType.
-class PyTupleType : public PyConcreteType<PyTupleType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsATuple;
-  static constexpr const char *pyClassName = "TupleType";
-  using PyConcreteType::PyConcreteType;
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get_tuple",
-        [](py::list elementList, DefaultingPyMlirContext context) {
-          intptr_t num = py::len(elementList);
-          // Mapping py::list to SmallVector.
-          SmallVector<MlirType, 4> elements;
-          for (auto element : elementList)
-            elements.push_back(element.cast<PyType>());
-          MlirType t = mlirTupleTypeGet(context->get(), num, elements.data());
-          return PyTupleType(context->getRef(), t);
-        },
-        py::arg("elements"), py::arg("context") = py::none(),
-        "Create a tuple type");
-    c.def(
-        "get_type",
-        [](PyTupleType &self, intptr_t pos) -> PyType {
-          MlirType t = mlirTupleTypeGetType(self, pos);
-          return PyType(self.getContext(), t);
-        },
-        py::arg("pos"), "Returns the pos-th type in the tuple type.");
-    c.def_property_readonly(
-        "num_types",
-        [](PyTupleType &self) -> intptr_t {
-          return mlirTupleTypeGetNumTypes(self);
-        },
-        "Returns the number of types contained in a tuple.");
-  }
-};
-
-/// Function type.
-class PyFunctionType : public PyConcreteType<PyFunctionType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAFunction;
-  static constexpr const char *pyClassName = "FunctionType";
-  using PyConcreteType::PyConcreteType;
+void PyTupleType::bindDerived(ClassTy &c) {
 
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](std::vector<PyType> inputs, std::vector<PyType> results,
-           DefaultingPyMlirContext context) {
-          SmallVector<MlirType, 4> inputsRaw(inputs.begin(), inputs.end());
-          SmallVector<MlirType, 4> resultsRaw(results.begin(), results.end());
-          MlirType t = mlirFunctionTypeGet(context->get(), inputsRaw.size(),
-                                           inputsRaw.data(), resultsRaw.size(),
-                                           resultsRaw.data());
-          return PyFunctionType(context->getRef(), t);
-        },
-        py::arg("inputs"), py::arg("results"), py::arg("context") = py::none(),
-        "Gets a FunctionType from a list of input and result types");
-    c.def_property_readonly(
-        "inputs",
-        [](PyFunctionType &self) {
-          MlirType t = self;
-          auto contextRef = self.getContext();
-          py::list types;
-          for (intptr_t i = 0, e = mlirFunctionTypeGetNumInputs(self); i < e;
-               ++i) {
-            types.append(PyType(contextRef, mlirFunctionTypeGetInput(t, i)));
-          }
-          return types;
-        },
-        "Returns the list of input types in the FunctionType.");
-    c.def_property_readonly(
-        "results",
-        [](PyFunctionType &self) {
-          auto contextRef = self.getContext();
-          py::list types;
-          for (intptr_t i = 0, e = mlirFunctionTypeGetNumResults(self); i < e;
-               ++i) {
-            types.append(
-                PyType(contextRef, mlirFunctionTypeGetResult(self, i)));
-          }
-          return types;
-        },
-        "Returns the list of result types in the FunctionType.");
-  }
-};
+void PyFunctionType::bindDerived(ClassTy &c) {
+          types.append(PyType(contextRef, mlirFunctionTypeGetResult(self, i)));
 
-static MlirStringRef toMlirStringRef(const std::string &s) {
-  return mlirStringRefCreate(s.data(), s.size());
-}
-
-/// Opaque Type subclass - OpaqueType.
-class PyOpaqueType : public PyConcreteType<PyOpaqueType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAOpaque;
-  static constexpr const char *pyClassName = "OpaqueType";
-  using PyConcreteType::PyConcreteType;
-
-  static void bindDerived(ClassTy &c) {
-    c.def_static(
-        "get",
-        [](std::string dialectNamespace, std::string typeData,
-           DefaultingPyMlirContext context) {
-          MlirType type = mlirOpaqueTypeGet(context->get(),
-                                            toMlirStringRef(dialectNamespace),
-                                            toMlirStringRef(typeData));
-          return PyOpaqueType(context->getRef(), type);
-        },
-        py::arg("dialect_namespace"), py::arg("buffer"),
-        py::arg("context") = py::none(),
-        "Create an unregistered (opaque) dialect type.");
-    c.def_property_readonly(
-        "dialect_namespace",
-        [](PyOpaqueType &self) {
-          MlirStringRef stringRef = mlirOpaqueTypeGetDialectNamespace(self);
-          return py::str(stringRef.data, stringRef.length);
-        },
-        "Returns the dialect namespace for the Opaque type as a string.");
-    c.def_property_readonly(
-        "data",
-        [](PyOpaqueType &self) {
-          MlirStringRef stringRef = mlirOpaqueTypeGetData(self);
-          return py::str(stringRef.data, stringRef.length);
-        },
-        "Returns the data for the Opaque type as a string.");
-  }
-};
+void PyOpaqueType::bindDerived(ClassTy &c) {
+        MlirType type =
+            mlirOpaqueTypeGet(context->get(), toMlirStringRef(dialectNamespace),
 
-} // namespace
+} // namespace mlir::python
 
 void mlir::python::populateIRTypes(py::module &m) {
   PyIntegerType::bind(m);
   PyIndexType::bind(m);
   PyFloat8E4M3FNType::bind(m);
   PyFloat8E5M2Type::bind(m);
   PyFloat8E4M3FNUZType::bind(m);
   PyFloat8E4M3B11FNUZType::bind(m);

mlir/test/python/ir/builtin_types.py

 # RUN: %PYTHON %s | FileCheck %s
 
 import gc
 from mlir.ir import *
+from mlir.dialects import arith
 
 def run(f):
   print("\nTEST:", f.__name__)
   f()
   gc.collect()
   assert Context._get_live_count() == 0
   return f
 

 # CHECK-LABEL: TEST: testShapedTypeConstants
 # Tests that ShapedType exposes magic value constants.
 @run
 def testShapedTypeConstants():
   # CHECK: <class 'int'>
   print(type(ShapedType.get_dynamic_size()))
   # CHECK: <class 'int'>
   print(type(ShapedType.get_dynamic_stride_or_offset()))
+
+
+# CHECK-LABEL: TEST: testConcreteTypesRoundTrip
+@run
+def testConcreteTypesRoundTrip():
+  with Context(), Location.unknown():
+    f16 = F16Type.get()
+    # CHECK: concrete type instance: f16
+    print("concrete type instance:", f16)
+    cst_f16 = arith.ConstantOp(f16, 0.0)
+    # CHECK: result type: f16
+    print("result type:", cst_f16.type)
+    # CHECK: python type name: F16Type
+    print("python type name:", type(cst_f16.type).__name__)
+
+    f32 = F32Type.get()
+    # CHECK: concrete type instance: f32
+    print("concrete type instance:", f32)
+    cst_f32 = arith.ConstantOp(f32, 0.0)
+    # CHECK: result type: f32
+    print("result type:", cst_f32.type)
+    # CHECK: python type name: F32Type
+    print("python type name:", type(cst_f32.type).__name__)
+
+    f64 = F64Type.get()
+    # CHECK: concrete type instance: f64
+    print("concrete type instance:", f64)
+    cst_f64 = arith.ConstantOp(f64, 0.0)
+    # CHECK: result type: f64
+    print("result type:", cst_f64.type)
+    # CHECK: python type name: F64Type
+    print("python type name:", type(cst_f64.type).__name__)
+
+    f8E4M3B11FNUZ = Float8E4M3B11FNUZType.get()
+    # CHECK: concrete type instance: f8E4M3B11FNUZ
+    print("concrete type instance:", f8E4M3B11FNUZ)
+    cst_f8E4M3B11FNUZ = arith.ConstantOp(f8E4M3B11FNUZ, 0.0)
+    # CHECK: result type: f8E4M3B11FNUZ
+    print("result type:", cst_f8E4M3B11FNUZ.type)
+    # CHECK: python type name: Float8E4M3B11FNUZType
+    print("python type name:", type(cst_f8E4M3B11FNUZ.type).__name__)
+
+    f8E4M3FN = Float8E4M3FNType.get()
+    # CHECK: concrete type instance: f8E4M3FN
+    print("concrete type instance:", f8E4M3FN)
+    cst_f8E4M3FN = arith.ConstantOp(f8E4M3FN, 0.0)
+    # CHECK: result type: f8E4M3FN
+    print("result type:", cst_f8E4M3FN.type)
+    # CHECK: python type name: Float8E4M3FNType
+    print("python type name:", type(cst_f8E4M3FN.type).__name__)
+
+    f8E4M3FNUZ = Float8E4M3FNUZType.get()
+    # CHECK: concrete type instance: f8E4M3FNUZ
+    print("concrete type instance:", f8E4M3FNUZ)
+    cst_f8E4M3FNUZ = arith.ConstantOp(f8E4M3FNUZ, 0.0)
+    # CHECK: result type: f8E4M3FNUZ
+    print("result type:", cst_f8E4M3FNUZ.type)
+    # CHECK: python type name: Float8E4M3FNUZType
+    print("python type name:", type(cst_f8E4M3FNUZ.type).__name__)
+
+    f8E5M2 = Float8E5M2Type.get()
+    # CHECK: concrete type instance: f8E5M2
+    print("concrete type instance:", f8E5M2)
+    cst_f8E5M2 = arith.ConstantOp(f8E5M2, 0.0)
+    # CHECK: result type: f8E5M2
+    print("result type:", cst_f8E5M2.type)
+    # CHECK: python type name: Float8E5M2Type
+    print("python type name:", type(cst_f8E5M2.type).__name__)
+
+    f8E5M2FNUZ = Float8E5M2FNUZType.get()
+    # CHECK: concrete type instance: f8E5M2FNUZ
+    print("concrete type instance:", f8E5M2FNUZ)
+    cst_f8E5M2FNUZ = arith.ConstantOp(f8E5M2FNUZ, 0.0)
+    # CHECK: result type: f8E5M2FNUZ
+    print("result type:", cst_f8E5M2FNUZ.type)
+    # CHECK: python type name: Float8E5M2FNUZType
+    print("python type name:", type(cst_f8E5M2FNUZ.type).__name__)
+
+    bf16 = BF16Type.get()
+    # CHECK: concrete type instance: bf16
+    print("concrete type instance:", bf16)
+    cst_bf16 = arith.ConstantOp(bf16, 0.0)
+    # CHECK: result type: bf16
+    print("result type:", cst_bf16.type)
+    # CHECK: python type name: BF16Type
+    print("python type name:", type(cst_bf16.type).__name__)
+
+    index = IndexType.get()
+    # CHECK: concrete type instance: index
+    print("concrete type instance:", index)
+    cst_index = arith.ConstantOp(index, 0)
+    # CHECK: result type: index
+    print("result type:", cst_index.type)
+    # CHECK: python type name: IndexType
+    print("python type name:", type(cst_index.type).__name__)
+
+    integer = IntegerType.get_signless(32)
+    # CHECK: concrete type instance: i32
+    print("concrete type instance:", integer)
+    cst_integer = arith.ConstantOp(integer, 0)
+    # CHECK: result type: i32
+    print("result type:", cst_integer.type)
+    # CHECK: python type name: IntegerType
+    print("python type name:", type(cst_integer.type).__name__)
 No newline at end of file