[mlir][python] Add __{bool,float,int,str}__ to bindings of attributes.

[ingomueller-net]

Summary

This allows to use Python's bool(.), float(.), int(.), and
str(.) to convert pybound attributes to the corresponding native
Python types. In particular, pybind11 uses these functions to
automatically cast objects to the corresponding primitive types wherever
they are required by pybound functions, e.g., arguments are converted to
Python's int if the C++ signature requires a C++ int. With this
patch, pybound attributes can by used wherever the corresponding native
types are expected. New tests show-case this behavior in the
constructors of Dense*ArrayAttr.

Note that this changes the output of Python's str on StringAttr from
"hello" to hello. Arguably, this is still in line with strs goal
of producing a readable interpretation of the value, even if it is now
not unambiously a string anymore (print(ir.Attribute.parse('"42"'))
now outputs 42). However, this is consistent with instances of
Python's str (print("42") outputs 42), and repr still provides
an unambigous representation if one is required.

[springerm]

mlir/test/python/ir/attributes.py

298

I'm surprised that this parses at all. What's happening here?

310

Why does this exist?

[ingomueller-net]

mlir/test/python/ir/attributes.py

298

Attribute.parse calls a C++ function that parses MLIR assembly. "stringattr" is the assembly of a StringAttr with the value stringattr and the type NoneType. "stringattr" : i32 is the assembly of a StringAttr with the value stringattr and the type i32.

310

typed_get is a method that constructs a StringAttr with the given value and the given type (see above). I can only assume that typed StringAttr are less common than those using NoneType, so the get function does not require a type.

[rkayaith]

In particular, pybind11 uses these functions to automatically cast objects to the corresponding primitive types wherever they are required by pybound functions, e.g., arguments are converted to Python's int if the C++ signature requires a C++ int.

Is this really true of __str__ as well? That'd be pretty surprising, as pretty much every python object is string-able.

[ingomueller-net]

I agree. I'll investigate tomorrow when I am back at work.

mlir/lib/Bindings/Python/IRAttributes.cpp

c.def_static(
         "get_f64",
         [](double value, DefaultingPyMlirContext context) {
           MlirAttribute attr = mlirFloatAttrDoubleGet(
               context->get(), mlirF64TypeGet(context->get()), value);
           return PyFloatAttribute(context->getRef(), attr);
         },
         py::arg("value"), py::arg("context") = py::none(),
         "Gets an uniqued float point attribute associated to a f64 type");
-    c.def_property_readonly(
-        "value",
-        [](PyFloatAttribute &self) {
-          return mlirFloatAttrGetValueDouble(self);
-        },
-        "Returns the value of the float point attribute");
+    c.def_property_readonly("value", mlirFloatAttrGetValueDouble,
+                            "Returns the value of the float attribute");
+    c.def("__float__", mlirFloatAttrGetValueDouble,
+          "Converts the value of the float attribute to a Python float");
   }
 };
 
 /// Integer Attribute subclass - IntegerAttr.
 class PyIntegerAttribute : public PyConcreteAttribute<PyIntegerAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAInteger;
   static constexpr const char *pyClassName = "IntegerAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](PyType &type, int64_t value) {
           MlirAttribute attr = mlirIntegerAttrGet(type, value);
           return PyIntegerAttribute(type.getContext(), attr);
         },
         py::arg("type"), py::arg("value"),
         "Gets an uniqued integer attribute associated to a type");
-    c.def_property_readonly(
-        "value",
-        [](PyIntegerAttribute &self) -> py::int_ {
-          MlirType type = mlirAttributeGetType(self);
-          if (mlirTypeIsAIndex(type) || mlirIntegerTypeIsSignless(type))
-            return mlirIntegerAttrGetValueInt(self);
-          if (mlirIntegerTypeIsSigned(type))
-            return mlirIntegerAttrGetValueSInt(self);
-          return mlirIntegerAttrGetValueUInt(self);
-        },
-        "Returns the value of the integer attribute");
-    c.def_property_readonly_static("static_typeid",
-                                   [](py::object & /*class*/) -> MlirTypeID {
-                                     return mlirIntegerAttrGetTypeID();
-                                   });
+    c.def_property_readonly("value", toPyInt,
+                            "Returns the value of the integer attribute");
+    c.def("__int__", toPyInt,
+          "Converts the value of the integer attribute to a Python int");
+    c.def_property_readonly_static("static_typeid",
+                                   [](py::object & /*class*/) -> MlirTypeID {
+                                     return mlirIntegerAttrGetTypeID();
+                                   });
+  }
+
+private:
+  static py::int_ toPyInt(PyIntegerAttribute &self) {
   }
 };
 
 /// Bool Attribute subclass - BoolAttr.
 class PyBoolAttribute : public PyConcreteAttribute<PyBoolAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsABool;
   static constexpr const char *pyClassName = "BoolAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](bool value, DefaultingPyMlirContext context) {
           MlirAttribute attr = mlirBoolAttrGet(context->get(), value);
           return PyBoolAttribute(context->getRef(), attr);
         },
         py::arg("value"), py::arg("context") = py::none(),
         "Gets an uniqued bool attribute");
-    c.def_property_readonly(
-        "value",
-        [](PyBoolAttribute &self) { return mlirBoolAttrGetValue(self); },
+    c.def_property_readonly("value", mlirBoolAttrGetValue,
                             "Returns the value of the bool attribute");
+    c.def("__bool__", mlirBoolAttrGetValue,
+          "Converts the value of the bool attribute to a Python bool");
   }
 };
 
 class PySymbolRefAttribute : public PyConcreteAttribute<PySymbolRefAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsASymbolRef;
   static constexpr const char *pyClassName = "SymbolRefAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
c.def_static(
         "get_typed",
         [](PyType &type, std::string value) {
           MlirAttribute attr =
               mlirStringAttrTypedGet(type, toMlirStringRef(value));
           return PyStringAttribute(type.getContext(), attr);
         },
         py::arg("type"), py::arg("value"),
         "Gets a uniqued string attribute associated to a type");
-    c.def_property_readonly(
-        "value",
-        [](PyStringAttribute &self) {
-          MlirStringRef stringRef = mlirStringAttrGetValue(self);
-          return py::str(stringRef.data, stringRef.length);
-        },
+    c.def_property_readonly("value", toPyStr,
                             "Returns the value of the string attribute");
     c.def_property_readonly(
         "value_bytes",
         [](PyStringAttribute &self) {
           MlirStringRef stringRef = mlirStringAttrGetValue(self);
           return py::bytes(stringRef.data, stringRef.length);
         },
         "Returns the value of the string attribute as `bytes`");
+    c.def("__str__", toPyStr,
+          "Converts the value of the string attribute to a Python str");
+  }
+
+private:
+  static py::str toPyStr(PyStringAttribute &self) {
+    MlirStringRef stringRef = mlirStringAttrGetValue(self);
+    return py::str(stringRef.data, stringRef.length);
   }
 };
 
 // TODO: Support construction of string elements.
 class PyDenseElementsAttribute
     : public PyConcreteAttribute<PyDenseElementsAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseElements;

mlir/test/python/ir/attributes.py

 # CHECK-LABEL: TEST: testParsePrint
 @run
 def testParsePrint():
     with Context() as ctx:
         t = Attribute.parse('"hello"')
     assert t.context is ctx
     ctx = None
     gc.collect()
-    # CHECK: "hello"
+    # CHECK: hello
     print(str(t))
     # CHECK: StringAttr("hello")
     print(repr(t))
 
 
 # CHECK-LABEL: TEST: testParseError
 @run
 def testParseError():

 
 # CHECK-LABEL: TEST: testFloatAttr
 @run
 def testFloatAttr():
     with Context(), Location.unknown():
         fattr = FloatAttr(Attribute.parse("42.0 : f32"))
         # CHECK: fattr value: 42.0
         print("fattr value:", fattr.value)
+        # CHECK: fattr float: 42.0 <class 'float'>
+        print("fattr float:", float(fattr), type(float(fattr)))
 
         # Test factory methods.
         # CHECK: default_get: 4.200000e+01 : f32
         print("default_get:", FloatAttr.get(F32Type.get(), 42.0))
         # CHECK: f32_get: 4.200000e+01 : f32
         print("f32_get:", FloatAttr.get_f32(42.0))
         # CHECK: f64_get: 4.200000e+01 : f64
         print("f64_get:", FloatAttr.get_f64(42.0))

 @run
 def testIntegerAttr():
     with Context() as ctx:
         i_attr = IntegerAttr(Attribute.parse("42"))
         # CHECK: i_attr value: 42
         print("i_attr value:", i_attr.value)
         # CHECK: i_attr type: i64
         print("i_attr type:", i_attr.type)
+        # CHECK: i_attr int: 42 <class 'int'>
+        print("i_attr int:", int(i_attr), type(int(i_attr)))
         si_attr = IntegerAttr(Attribute.parse("-1 : si8"))
         # CHECK: si_attr value: -1
         print("si_attr value:", si_attr.value)
         ui_attr = IntegerAttr(Attribute.parse("255 : ui8"))
+        # CHECK: i_attr int: -1 <class 'int'>
+        print("si_attr int:", int(si_attr), type(int(si_attr)))
         # CHECK: ui_attr value: 255
         print("ui_attr value:", ui_attr.value)
+        # CHECK: i_attr int: 255 <class 'int'>
+        print("ui_attr int:", int(ui_attr), type(int(ui_attr)))
         idx_attr = IntegerAttr(Attribute.parse("-1 : index"))
         # CHECK: idx_attr value: -1
         print("idx_attr value:", idx_attr.value)
+        # CHECK: idx_attr int: -1 <class 'int'>
+        print("idx_attr int:", int(idx_attr), type(int(idx_attr)))
 
         # Test factory methods.
         # CHECK: default_get: 42 : i32
         print("default_get:", IntegerAttr.get(IntegerType.get_signless(32), 42))
 
 
 # CHECK-LABEL: TEST: testBoolAttr
 @run
 def testBoolAttr():
     with Context() as ctx:
         battr = BoolAttr(Attribute.parse("true"))
         # CHECK: iattr value: True
         print("iattr value:", battr.value)
+        # CHECK: iattr bool: True <class 'bool'>
+        print("iattr bool:", bool(battr), type(bool(battr)))
 
         # Test factory methods.
         # CHECK: default_get: true
         print("default_get:", BoolAttr.get(True))
 
 
 # CHECK-LABEL: TEST: testFlatSymbolRefAttr
 @run

 
 # CHECK-LABEL: TEST: testStringAttr
 @run
 def testStringAttr():
     with Context() as ctx:
         sattr = StringAttr(Attribute.parse('"stringattr"'))
         # CHECK: sattr value: stringattr
         print("sattr value:", sattr.value)
-        # CHECK: sattr value: b'stringattr'
-        print("sattr value:", sattr.value_bytes)
+        # CHECK: sattr value_bytes: b'stringattr'
+        print("sattr value_bytes:", sattr.value_bytes)
+        # CHECK: sattr str: stringattr
+        print("sattr str:", str(sattr))
+
+        typed_sattr = StringAttr(Attribute.parse('"stringattr" : i32'))
+        # CHECK: typed_sattr value: stringattr
+        print("typed_sattr value:", typed_sattr.value)
+        # CHECK: typed_sattr str: stringattr
+        print("typed_sattr str:", str(typed_sattr))
 
         # Test factory methods.
-        # CHECK: default_get: "foobar"
-        print("default_get:", StringAttr.get("foobar"))
-        # CHECK: typed_get: "12345" : i32
-        print("typed_get:", StringAttr.get_typed(IntegerType.get_signless(32), "12345"))
+        # CHECK: default_get: StringAttr("foobar")
+        print("default_get:", repr(StringAttr.get("foobar")))
+        # CHECK: typed_get: StringAttr("12345" : i32)
+        print(
+            "typed_get:",
+            repr(StringAttr.get_typed(IntegerType.get_signless(32), "12345")),
+        )
 
 
 # CHECK-LABEL: TEST: testNamedAttr
 @run
 def testNamedAttr():
     with Context():
         a = Attribute.parse('"stringattr"')
         named = a.get_named("foobar")  # Note: under the small object threshold
-        # CHECK: attr: "stringattr"
-        print("attr:", named.attr)
+        # CHECK: attr: StringAttr("stringattr")
+        print("attr:", repr(named.attr))
         # CHECK: name: foobar
         print("name:", named.name)
         # CHECK: named: NamedAttribute(foobar="stringattr")
         print("named:", named)
 
 
 # CHECK-LABEL: TEST: testDenseIntAttr
 @run
with Context():
         class MyBool:
             def __bool__(self):
                 return True
 
         # CHECK: myboolarray: array<i1: true>
         print("myboolarray:", DenseBoolArrayAttr.get([MyBool()]))
 
 
+# CHECK-LABEL: TEST: testDenseArrayAttrConstruction
+@run
+def testDenseArrayAttrConstruction():
+    with Context(), Location.unknown():
+
+        def create_and_print(cls, x):
+            try:
+                darr = cls.get(x)
+                print(f"input: {x} ({type(x)}), result: {darr}")
+            except Exception as ex:
+                print(f"input: {x} ({type(x)}), error: {ex}")
+
+        # CHECK: input: [4, 2] (<class 'list'>),
+        # CHECK-SAME: result: array<i8: 4, 2>
+        create_and_print(DenseI8ArrayAttr, [4, 2])
+
+        # CHECK: input: [4, 2.0] (<class 'list'>),
+        # CHECK-SAME: error: get(): incompatible function arguments
+        create_and_print(DenseI8ArrayAttr, [4, 2.0])
+
+        # CHECK: input: [40000, 2] (<class 'list'>),
+        # CHECK-SAME: error: get(): incompatible function arguments
+        create_and_print(DenseI8ArrayAttr, [40000, 2])
+
+        # CHECK: input: range(0, 4) (<class 'range'>),
+        # CHECK-SAME: result: array<i8: 0, 1, 2, 3>
+        create_and_print(DenseI8ArrayAttr, range(4))
+
+        # CHECK: input: [IntegerAttr(4 : i64), IntegerAttr(2 : i64)] (<class 'list'>),
+        # CHECK-SAME: result: array<i8: 4, 2>
+        create_and_print(DenseI8ArrayAttr, [Attribute.parse(f"{x}") for x in [4, 2]])
+
+        # CHECK: input: [IntegerAttr(4000 : i64), IntegerAttr(2 : i64)] (<class 'list'>),
+        # CHECK-SAME: error: get(): incompatible function arguments
+        create_and_print(DenseI8ArrayAttr, [Attribute.parse(f"{x}") for x in [4000, 2]])
+
+        # CHECK: input: [IntegerAttr(4 : i64), FloatAttr(2.000000e+00 : f64)] (<class 'list'>),
+        # CHECK-SAME: error: get(): incompatible function arguments
+        create_and_print(DenseI8ArrayAttr, [Attribute.parse(f"{x}") for x in [4, 2.0]])
+
+        # CHECK: input: [IntegerAttr(4 : i8), IntegerAttr(2 : ui16)] (<class 'list'>),
+        # CHECK-SAME: result: array<i8: 4, 2>
+        create_and_print(
+            DenseI8ArrayAttr, [Attribute.parse(s) for s in ["4 : i8", "2 : ui16"]]
+        )
+
+        # CHECK: input: [FloatAttr(4.000000e+00 : f64), FloatAttr(2.000000e+00 : f64)] (<class 'list'>)
+        # CHECK-SAME: result: array<f32: 4.000000e+00, 2.000000e+00>
+        create_and_print(
+            DenseF32ArrayAttr, [Attribute.parse(f"{x}") for x in [4.0, 2.0]]
+        )
+
+        # CHECK: [BoolAttr(true), BoolAttr(false)] (<class 'list'>),
+        # CHECK-SAME: result: array<i1: true, false>
+        create_and_print(
+            DenseBoolArrayAttr, [Attribute.parse(f"{x}") for x in ["true", "false"]]
+        )
+
+
 # CHECK-LABEL: TEST: testDenseIntAttrGetItem
 @run
 def testDenseIntAttrGetItem():
     def print_item(attr_asm):
         attr = Attribute.parse(attr_asm)
         dtype = ShapedType(attr.type).element_type
         try:
             item = attr[0]
with Context(), Location.unknown():
         # CHECK: F32Type(f32)
         print(repr(type_attr.value.element_type))
 
 
 # CHECK-LABEL: TEST: testConcreteAttributesRoundTrip
 @run
 def testConcreteAttributesRoundTrip():
     with Context(), Location.unknown():
-
         # CHECK: FloatAttr(4.200000e+01 : f32)
         print(repr(Attribute.parse("42.0 : f32")))
 
         assert IntegerAttr.static_typeid is not None