[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

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

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

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

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

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

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/IRAttributes.cpp

 //===- IRAttributes.cpp - Exports builtin and standard attributes ---------===//
 //
 // 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 <utility>
 #include <optional>
+#include <utility>
 
 #include "IRModule.h"
 
 #include "PybindUtils.h"
 
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir-c/BuiltinTypes.h"
 
c.def_static(
         "get",
         [](PyType value, DefaultingPyMlirContext context) {
           MlirAttribute attr = mlirTypeAttrGet(value.get());
           return PyTypeAttribute(context->getRef(), attr);
         },
         py::arg("value"), py::arg("context") = py::none(),
         "Gets a uniqued Type attribute");
     c.def_property_readonly("value", [](PyTypeAttribute &self) {
-      return PyType(self.getContext()->getRef(),
-                    mlirTypeAttrGetValue(self.get()));
+      return mlirTypeAttrGetValue(self.get());
     });
   }
 };
 
 /// Unit Attribute subclass. Unit attributes don't have values.
 class PyUnitAttribute : public PyConcreteAttribute<PyUnitAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAUnit;

mlir/lib/Bindings/Python/IRCore.cpp

 #include "mlir-c/Debug.h"
 #include "mlir-c/Diagnostics.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include <optional>
+#include <pybind11/attr.h>
+#include <pybind11/pybind11.h>
 #include <utility>
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
 using llvm::SmallVector;
 using llvm::StringRef;
py::class_<PyAttribute>(m, "Attribute", py::module_local())
           },
           py::arg("asm"), py::arg("context") = py::none(),
           "Parses an attribute from an assembly form. Raises an MLIRError on "
           "failure.")
       .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));
-                             })
+      .def_property_readonly(
+          "type", [](PyAttribute &self) { return mlirAttributeGetType(self); })
       .def(
           "get_named",
           [](PyAttribute &self, std::string name) {
             return PyNamedAttribute(self, std::move(name));
           },
           py::keep_alive<0, 1>(), "Binds a name to the attribute")
       .def("__eq__",
            [](PyAttribute &self, PyAttribute &other) { return self == other; })
py::class_<PyType>(m, "Type", py::module_local())
       .def_static(
           "parse",
           [](std::string typeSpec, DefaultingPyMlirContext context) {
             PyMlirContext::ErrorCapture errors(context->getRef());
             MlirType type =
                 mlirTypeParseGet(context->get(), toMlirStringRef(typeSpec));
             if (mlirTypeIsNull(type))
               throw MLIRError("Unable to parse type", errors.take());
-            return PyType(context->getRef(), type);
+            return type;
           },
           py::arg("asm"), py::arg("context") = py::none(),
           kContextParseTypeDocstring)
       .def_property_readonly(
           "context", [](PyType &self) { return self.getContext().getObject(); },
           "Context that owns the Type")
       .def("__eq__", [](PyType &self, PyType &other) { return self == other; })
       .def("__eq__", [](PyType &self, py::object &other) { return false; })
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/IRModule.h

 #include <optional>
 #include <utility>
 #include <vector>
 
 #include "PybindUtils.h"
 
 #include "mlir-c/AffineExpr.h"
 #include "mlir-c/AffineMap.h"
+#include "mlir-c/Bindings/Python/Interop.h"
+#include "mlir-c/BuiltinTypes.h"
 #include "mlir-c/Diagnostics.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/IntegerSet.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace mlir {
 namespace python {
 
static void bind(pybind11::module &m) {
     cls.def(pybind11::init<PyType &>(), pybind11::keep_alive<0, 1>(),
             pybind11::arg("cast_from_type"));
     cls.def_static(
         "isinstance",
         [](PyType &otherType) -> bool {
           return DerivedTy::isaFunction(otherType);
         },
         pybind11::arg("other"));
+    cls.def("__repr__", [](DerivedTy &self) {
+      PyPrintAccumulator printAccum;
+      printAccum.parts.append(DerivedTy::pyClassName);
+      printAccum.parts.append("(");
+      mlirTypePrint(self, printAccum.getCallback(), printAccum.getUserData());
+      printAccum.parts.append(")");
+      return printAccum.join();
+    });
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
 /// Wrapper around the generic MlirAttribute.
static void bind(pybind11::module &m) {
     cls.def(pybind11::init<PyAttribute &>(), pybind11::keep_alive<0, 1>(),
             pybind11::arg("cast_from_attr"));
     cls.def_static(
         "isinstance",
         [](PyAttribute &otherAttr) -> bool {
           return DerivedTy::isaFunction(otherAttr);
         },
         pybind11::arg("other"));
-    cls.def_property_readonly("type", [](PyAttribute &attr) {
-      return PyType(attr.getContext(), mlirAttributeGetType(attr));
-    });
+    cls.def_property_readonly(
+        "type", [](PyAttribute &attr) { return mlirAttributeGetType(attr); });
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
 /// Wrapper around the generic MlirValue.

 };
 
 void populateIRAffine(pybind11::module &m);
 void populateIRAttributes(pybind11::module &m);
 void populateIRCore(pybind11::module &m);
 void populateIRInterfaces(pybind11::module &m);
 void populateIRTypes(pybind11::module &m);
 
+// Note order here matters; firstly with respect to overhead; more common types
+// should match earliest in the if-case tree. Secondly, concrete types that have
+// a base type (such as all of the ShapedTypes) should come before the base type
+// to prevent a "less-refined-than-possible" match.
+#define FORALL_NO_BASE_CONCRETE_TYPES(_)                                       \
+  _(Index)                                                                     \
+  _(Integer)                                                                   \
+  _(F16)                                                                       \
+  _(F32)                                                                       \
+  _(F64)                                                                       \
+  _(Complex)                                                                   \
+  _(BF16)                                                                      \
+  _(Float8E4M3B11FNUZ)                                                         \
+  _(Float8E4M3FN)                                                              \
+  _(Float8E4M3FNUZ)                                                            \
+  _(Float8E5M2)                                                                \
+  _(Float8E5M2FNUZ)                                                            \
+  _(Function)                                                                  \
+  _(None)                                                                      \
+  _(Opaque)                                                                    \
+  _(Tuple)
+
+#define FORALL_SHAPE_BASE_CONCRETE_TYPES(_)                                    \
+  _(RankedTensor)                                                              \
+  _(UnrankedTensor)                                                            \
+  _(UnrankedMemRef)                                                            \
+  _(MemRef)                                                                    \
+  _(Vector)
+
+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();
+};
+
+#define DEFINE_WITH_BASE_CONCRETE_TYPE(CONCRETETYPE, BASETYPE)                 \
+  class Py##CONCRETETYPE##Type                                                 \
+      : public PyConcreteType<Py##CONCRETETYPE##Type, Py##BASETYPE> {          \
+  public:                                                                      \
+    static constexpr IsAFunctionTy isaFunction = mlirTypeIsA##CONCRETETYPE;    \
+    static constexpr const char *pyClassName = #CONCRETETYPE "Type";           \
+    using PyConcreteType::PyConcreteType;                                      \
+    static void bindDerived(ClassTy &c);                                       \
+  };
+
+#define DEFINE_SHAPE_BASE_CONCRETE_TYPE(CONCRETETYPE)                          \
+  DEFINE_WITH_BASE_CONCRETE_TYPE(CONCRETETYPE, ShapedType)
+FORALL_SHAPE_BASE_CONCRETE_TYPES(DEFINE_SHAPE_BASE_CONCRETE_TYPE)
+#undef DEFINE_SHAPE_BASE_CONCRETE_TYPE
+
+#define DEFINE_NO_BASE_CONCRETE_TYPE(CONCRETETYPE)                             \
+  DEFINE_WITH_BASE_CONCRETE_TYPE(CONCRETETYPE, Type)
+FORALL_NO_BASE_CONCRETE_TYPES(DEFINE_NO_BASE_CONCRETE_TYPE)
+#undef DEFINE_NO_BASE_CONCRETE_TYPE
+
 } // namespace python
 } // namespace mlir
 
 namespace pybind11 {
 namespace detail {
+using namespace mlir::python;
 
 template <>
-struct type_caster<mlir::python::DefaultingPyMlirContext>
-    : MlirDefaultingCaster<mlir::python::DefaultingPyMlirContext> {};
+struct type_caster<DefaultingPyMlirContext>
+    : MlirDefaultingCaster<DefaultingPyMlirContext> {};
+template <>
+struct type_caster<DefaultingPyLocation>
+    : MlirDefaultingCaster<DefaultingPyLocation> {};
+
+/// Casts MlirType that matches one of the concretes above -> ConcreteType.
 template <>
-struct type_caster<mlir::python::DefaultingPyLocation>
-    : MlirDefaultingCaster<mlir::python::DefaultingPyLocation> {};
+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_TYPE_MATCH(TTT)                                                 \
+  if (Py##TTT##Type::isaFunction(t)) {                                         \
+    return pybind11::cast(Py##TTT##Type(context, t)).release();                \
+  }
+    FORALL_SHAPE_BASE_CONCRETE_TYPES(DEFINE_TYPE_MATCH)
+    // just do one (Shaped)
+    DEFINE_TYPE_MATCH(Shaped)
+    FORALL_NO_BASE_CONCRETE_TYPES(DEFINE_TYPE_MATCH)
+#undef DEFINE_TYPE_MATCH
+
+    return pybind11::cast(PyType(context, t)).release();
+  }
+};
 
 } // namespace detail
 } // namespace pybind11
 
 #endif // MLIR_BINDINGS_PYTHON_IRMODULES_H

mlir/lib/Bindings/Python/IRTypes.cpp

 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
+
+namespace mlir::python {
 
-  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");
-  }
-};
-
-/// Index Type subclass - IndexType.
-class PyIndexType : public PyConcreteType<PyIndexType> {
-public:
-  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAIndex;
-  static constexpr const char *pyClassName = "IndexType";
-  using PyConcreteType::PyConcreteType;
+void PyIntegerType::bindDerived(ClassTy &c) {
+      [](PyIntegerType &self) -> bool { return mlirIntegerTypeIsSigned(self); },
 
-  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.");
-  }
-};
+void PyIndexType::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) {
-    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.");
-  }
-};
-
-/// 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;
+void PyFloat8E4M3FNType::bindDerived(ClassTy &c) {
 
-  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.");
-  }
-};
+void PyFloat8E5M2Type::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) {
-    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.");
-  }
-};
-
-/// 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;
+void PyFloat8E4M3B11FNUZType::bindDerived(ClassTy &c) {
 
-  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.");
-  }
-};
+void PyFloat8E5M2FNUZType::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) {
-    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.");
-  }
-};
-
-/// 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;
+void PyBF16Type::bindDerived(ClassTy &c) {
 
-  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.");
-  }
-};
+void PyF16Type::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) {
-    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.");
-  }
-};
-
-/// 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;
+void PyF32Type::bindDerived(ClassTy &c) {
 
-  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.");
-  }
-};
+void PyComplexType::bindDerived(ClassTy &c) {
+      [](PyComplexType &self) { return mlirComplexTypeGetElementType(self); },
 
-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) {
-    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) {
+      [](PyShapedType &self) { return mlirShapedTypeGetElementType(self); },
 
-          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");
-  }
-};
-
-/// 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;
+void PyVectorType::bindDerived(ClassTy &c) {
 
-  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");
-  }
-};
+void PyUnrankedTensorType::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) {
-    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.");
-  }
-};
-
-/// 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;
+void PyMemRefType::bindDerived(ClassTy &c) {
+       [](std::vector<int64_t> shape, PyType &elementType, PyAttribute *layout,
+          PyAttribute *memorySpace, DefaultingPyLocation loc) {
 
-  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.");
-  }
-};
+void PyTupleType::bindDerived(ClassTy &c) {
+        return mlirTupleTypeGet(context->get(), num, elements.data());
+      [](PyTupleType &self, intptr_t pos) {
+        return mlirTupleTypeGetType(self, pos);
 
-/// 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) {
-    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.");
-  }
-};
-
-static MlirStringRef toMlirStringRef(const std::string &s) {
-  return mlirStringRefCreate(s.data(), s.size());
-}
+void PyFunctionType::bindDerived(ClassTy &c) {
+          types.append(mlirFunctionTypeGetInput(t, i));
+          types.append(mlirFunctionTypeGetResult(self, i));
 
-/// 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/attributes.py

with Context():
     # CHECK: strided<[?, ?, ?], offset: ?>
     print(attr)
     # CHECK: offset is dynamic: True
     print(f"offset is dynamic: {attr.offset == dynamic}")
     # CHECK: rank: 3
     print(f"rank: {len(attr.strides)}")
     # CHECK: strides are dynamic: [True, True, True]
     print(f"strides are dynamic: {[s == dynamic for s in attr.strides]}")
+
+
+# CHECK-LABEL: TEST: testConcreteTypesRoundTrip
+@run
+def testConcreteTypesRoundTrip():
+  with Context(), Location.unknown():
+    def print_item(attr):
+      print(repr(attr.type))
+
+    # CHECK: F32Type(f32)
+    print_item(Attribute.parse("42.0 : f32"))
+    # CHECK: F32Type(f32)
+    print_item(FloatAttr.get_f32(42.0))
+    # CHECK: F64Type(f64)
+    print_item(FloatAttr.get_f64(42.0))
+    # CHECK: IntegerType(i32)
+    print_item(IntegerAttr.get(IntegerType.get_signless(32), 42))
+    # CHECK: IntegerType(i64)
+    print_item(IntegerAttr.get(IntegerType.get_signless(64), 42))
+
+    def print_container_item(attr_asm):
+      attr = DenseElementsAttr(Attribute.parse(attr_asm))
+      print(repr(attr.type))
+      print(repr(attr.type.element_type))
+
+    # CHECK: RankedTensorType(tensor<i16>)
+    # CHECK: IntegerType(i16)
+    print_container_item("dense<123> : tensor<i16>")
+    # CHECK: RankedTensorType(tensor<i32>)
+    # CHECK: IntegerType(i32)
+    print_container_item("dense<123> : tensor<i32>")
+    # CHECK: RankedTensorType(tensor<i64>)
+    # CHECK: IntegerType(i64)
+    print_container_item("dense<123> : tensor<i64>")
+
+    # CHECK: RankedTensorType(tensor<f16>)
+    # CHECK: F16Type(f16)
+    print_container_item("dense<1.0> : tensor<f16>")
+    # CHECK: RankedTensorType(tensor<f32>)
+    # CHECK: F32Type(f32)
+    print_container_item("dense<1.0> : tensor<f32>")
+    # CHECK: RankedTensorType(tensor<f64>)
+    # CHECK: F64Type(f64)
+    print_container_item("dense<1.0> : tensor<f64>")
+
+    raw = Attribute.parse("vector<4xf32>")
+    # CHECK: attr: vector<4xf32>
+    print("attr:", raw)
+    type_attr = TypeAttr(raw)
+
+    # CHECK: VectorType(vector<4xf32>)
+    print(repr(type_attr.value))
+    # CHECK: F32Type(f32)
+    print(repr(type_attr.value.element_type))

mlir/test/python/ir/builtin_types.py

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

 
 # CHECK-LABEL: TEST: testMemRefType
 @run
 def testMemRefType():
   with Context(), Location.unknown():
     f32 = F32Type.get()
     shape = [2, 3]
     loc = Location.unknown()
-    memref = MemRefType.get(shape, f32, memory_space=Attribute.parse("2"))
+    memref_f32 = MemRefType.get(shape, f32, memory_space=Attribute.parse("2"))
     # CHECK: memref type: memref<2x3xf32, 2>
-    print("memref type:", memref)
+    print("memref type:", memref_f32)
     # CHECK: memref layout: affine_map<(d0, d1) -> (d0, d1)>
-    print("memref layout:", memref.layout)
+    print("memref layout:", memref_f32.layout)
     # CHECK: memref affine map: (d0, d1) -> (d0, d1)
-    print("memref affine map:", memref.affine_map)
+    print("memref affine map:", memref_f32.affine_map)
     # CHECK: memory space: 2
-    print("memory space:", memref.memory_space)
+    print("memory space:", memref_f32.memory_space)
 
     layout = AffineMapAttr.get(AffineMap.get_permutation([1, 0]))
     memref_layout = MemRefType.get(shape, f32, layout=layout)
     # CHECK: memref type: memref<2x3xf32, affine_map<(d0, d1) -> (d1, d0)>>
     print("memref type:", memref_layout)
     # CHECK: memref layout: affine_map<(d0, d1) -> (d1, d0)>
     print("memref layout:", memref_layout.layout)
     # CHECK: memref affine map: (d0, d1) -> (d1, d0)
     print("memref affine map:", memref_layout.affine_map)
     # CHECK: memory space: <<NULL ATTRIBUTE>>
     print("memory space:", memref_layout.memory_space)
 
     none = NoneType.get()
     try:
       memref_invalid = MemRefType.get(shape, none)
     except MLIRError as e:
       # CHECK: Invalid type:
       # CHECK: error: unknown: invalid memref element type
       print(e)
     else:
       print("Exception not produced")
 
-    assert memref.shape == shape
+    assert memref_f32.shape == shape
 
 
 # CHECK-LABEL: TEST: testUnrankedMemRefType
 @run
 def testUnrankedMemRefType():
   with Context(), Location.unknown():
     f32 = F32Type.get()
     loc = Location.unknown()

 # CHECK-LABEL: TEST: testFunctionType
 @run
 def testFunctionType():
   with Context() as ctx:
     input_types = [IntegerType.get_signless(32),
                   IntegerType.get_signless(16)]
     result_types = [IndexType.get()]
     func = FunctionType.get(input_types, result_types)
-    # CHECK: INPUTS: [Type(i32), Type(i16)]
+    # CHECK: INPUTS: [IntegerType(i32), IntegerType(i16)]
     print("INPUTS:", func.inputs)
-    # CHECK: RESULTS: [Type(index)]
+    # CHECK: RESULTS: [IndexType(index)]
     print("RESULTS:", func.results)
 
 
 # CHECK-LABEL: TEST: testOpaqueType
 @run
 def testOpaqueType():
   with Context() as ctx:
     ctx.allow_unregistered_dialects = True

 # 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() as ctx, Location.unknown():
+    ctx.allow_unregistered_dialects = True
+    def print_item(typ, v):
+      cst = arith.ConstantOp(typ, v).result
+      print(type(cst.type).__name__)
+      print(repr(cst.type))
+
+    # CHECK: F16Type
+    # CHECK: F16Type(f16)
+    print_item(F16Type.get(), 0.0)
+    # CHECK: F32Type
+    # CHECK: F32Type(f32)
+    print_item(F32Type.get(), 0.0)
+    # CHECK: F64Type
+    # CHECK: F64Type(f64)
+    print_item(F64Type.get(), 0.0)
+    # CHECK: Float8E4M3B11FNUZType
+    # CHECK: Float8E4M3B11FNUZType(f8E4M3B11FNUZ)
+    print_item(Float8E4M3B11FNUZType.get(), 0.0)
+    # CHECK: Float8E4M3FNType
+    # CHECK: Float8E4M3FNType(f8E4M3FN)
+    print_item(Float8E4M3FNType.get(), 0.0)
+    # CHECK: Float8E4M3FNUZType
+    # CHECK: Float8E4M3FNUZType(f8E4M3FNUZ)
+    print_item(Float8E4M3FNUZType.get(), 0.0)
+    # CHECK: Float8E5M2Type
+    # CHECK: Float8E5M2Type(f8E5M2)
+    print_item(Float8E5M2Type.get(), 0.0)
+    # CHECK: Float8E5M2FNUZType
+    # CHECK: Float8E5M2FNUZType(f8E5M2FNUZ)
+    print_item(Float8E5M2FNUZType.get(), 0.0)
+    # CHECK: BF16Type
+    # CHECK: BF16Type(bf16)
+    print_item(BF16Type.get(), 0.0)
+    # CHECK: IndexType
+    # CHECK: IndexType(index)
+    print_item(IndexType.get(), 0)
+    # CHECK: IntegerType
+    # CHECK: IntegerType(i32)
+    print_item(IntegerType.get_signless(32), 0)
+
+    f32 = F32Type.get()
+    ranked_tensor = tensor.EmptyOp([10, 10], f32).result
+    # CHECK: RankedTensorType
+    print(type(ranked_tensor.type).__name__)
+    # CHECK: RankedTensorType(tensor<10x10xf32>)
+    print(repr(ranked_tensor.type))
+
+    cf32 = ComplexType.get(f32)
+    # CHECK: ComplexType
+    print(type(cf32).__name__)
+    # CHECK: ComplexType(complex<f32>)
+    print(repr(cf32))
+
+    ranked_tensor = tensor.EmptyOp([10, 10], f32).result
+    # CHECK: RankedTensorType
+    print(type(ranked_tensor.type).__name__)
+    # CHECK: RankedTensorType(tensor<10x10xf32>)
+    print(repr(ranked_tensor.type))
+
+    vector = VectorType.get([10, 10], f32)
+    tuple_type = TupleType.get_tuple([f32, vector])
+    # CHECK: TupleType
+    print(type(tuple_type).__name__)
+    # CHECK: TupleType(tuple<f32, vector<10x10xf32>>)
+    print(repr(tuple_type))
+    # CHECK: F32Type(f32)
+    print(repr(tuple_type.get_type(0)))
+    # CHECK: VectorType(vector<10x10xf32>)
+    print(repr(tuple_type.get_type(1)))
+
+    index_type = IndexType.get()
+    @func.FuncOp.from_py_func()
+    def default_builder():
+      c0 = arith.ConstantOp(f32, 0.0)
+      unranked_tensor_type = UnrankedTensorType.get(f32)
+      unranked_tensor = tensor.FromElementsOp(unranked_tensor_type, [c0]).result
+      # CHECK: UnrankedTensorType
+      print(type(unranked_tensor.type).__name__)
+      # CHECK: UnrankedTensorType(tensor<*xf32>)
+      print(repr(unranked_tensor.type))
+
+      c10 = arith.ConstantOp(index_type, 10)
+      memref_f32_t = MemRefType.get([10, 10], f32)
+      memref_f32 = memref.AllocOp(memref_f32_t, [c10, c10], []).result
+      # CHECK: MemRefType
+      print(type(memref_f32.type).__name__)
+      # CHECK: MemRefType(memref<10x10xf32>)
+      print(repr(memref_f32.type))
+
+      unranked_memref_t = UnrankedMemRefType.get(f32, Attribute.parse("2"))
+      memref_f32 = memref.AllocOp(unranked_memref_t, [c10, c10], []).result
+      # CHECK: UnrankedMemRefType
+      print(type(memref_f32.type).__name__)
+      # CHECK: UnrankedMemRefType(memref<*xf32, 2>)
+      print(repr(memref_f32.type))
+
+      tuple_type = Operation.parse(f'"test.make_tuple"() : () -> tuple<i32, f32>').result
+      # CHECK: TupleType
+      print(type(tuple_type.type).__name__)
+      # CHECK: TupleType(tuple<i32, f32>)
+      print(repr(tuple_type.type))
+
+      return c0, c10
+
+    func_op = default_builder.func_op
+    # CHECK: FunctionType
+    print(type(func_op.type).__name__)
+    # CHECK: FunctionType(() -> (f32, index))
+    print(repr(func_op.type))
+    # CHECK: []
+    print(func_op.type.inputs)
+    # CHECK: [F32Type(f32), IndexType(index)]
+    print(func_op.type.results)