[mlir][python] Make DenseBoolArrayAttr.get work with list of bools.

[ingomueller-net]

Summary

This patch makes the getter function of DenseBoolArrayAttr work more
intuitively. Until now, it was implemented with a std::vector<int>
argument, which works in the typical situation where you call the pybind
function with a list of Python bools (like [True, False]). However, it
does *not* work if the elements of the list have to be cast to Bool
before (and that is the default behavior for lists of all other types).
The patch thus changes the signature to std::vector<bool>, which helps
pybind to make the function behave as expected for bools. The tests now
also contain a case where such a cast is happening. This also makes the
conversion of DenseBoolArrayAttr back to Python more intuitive:
instead of converting to 0 and 1, the elements are now converted to
False and True.

mlir/lib/Bindings/Python/IRAttributes.cpp

public:
   EltTy getItem(intptr_t i) { return DerivedT::getElement(*this, i); }
 
   /// Bind the attribute class.
   static void bindDerived(typename PyConcreteAttribute<DerivedT>::ClassTy &c) {
     // Bind the constructor.
     c.def_static(
         "get",
         [](const std::vector<EltTy> &values, DefaultingPyMlirContext ctx) {
-          MlirAttribute attr =
-              DerivedT::getAttribute(ctx->get(), values.size(), values.data());
-          return DerivedT(ctx->getRef(), attr);
+          return getAttribute(values, ctx->getRef());
         },
         py::arg("values"), py::arg("context") = py::none(),
         "Gets a uniqued dense array attribute");
     // Bind the array methods.
     c.def("__getitem__", [](DerivedT &arr, intptr_t i) {
       if (i >= mlirDenseArrayGetNumElements(arr))
         throw py::index_error("DenseArray index out of range");
       return arr.getItem(i);
     });
     c.def("__len__", [](const DerivedT &arr) {
       return mlirDenseArrayGetNumElements(arr);
     });
     c.def("__iter__",
           [](const DerivedT &arr) { return PyDenseArrayIterator(arr); });
     c.def("__add__", [](DerivedT &arr, const py::list &extras) {
       std::vector<EltTy> values;
       intptr_t numOldElements = mlirDenseArrayGetNumElements(arr);
       values.reserve(numOldElements + py::len(extras));
       for (intptr_t i = 0; i < numOldElements; ++i)
         values.push_back(arr.getItem(i));
       for (py::handle attr : extras)
         values.push_back(pyTryCast<EltTy>(attr));
-      MlirAttribute attr = DerivedT::getAttribute(arr.getContext()->get(),
-                                                  values.size(), values.data());
-      return DerivedT(arr.getContext(), attr);
+      return getAttribute(values, arr.getContext());
     });
   }
+
+private:
+  static DerivedT getAttribute(const std::vector<EltTy> &values,
+                               PyMlirContextRef ctx) {
+    if constexpr (std::is_same_v<EltTy, bool>) {
+      std::vector<int> intValues(values.begin(), values.end());
+      MlirAttribute attr = DerivedT::getAttribute(ctx->get(), intValues.size(),
+                                                  intValues.data());
+      return DerivedT(ctx, attr);
+    } else {
+      MlirAttribute attr =
+          DerivedT::getAttribute(ctx->get(), values.size(), values.data());
+      return DerivedT(ctx, attr);
+    }
+  }
 };
 
 /// Instantiate the python dense array classes.
 struct PyDenseBoolArrayAttribute
-    : public PyDenseArrayAttribute<int, PyDenseBoolArrayAttribute> {
+    : public PyDenseArrayAttribute<bool, PyDenseBoolArrayAttribute> {
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseBoolArray;
   static constexpr auto getAttribute = mlirDenseBoolArrayGet;
   static constexpr auto getElement = mlirDenseBoolArrayGetElement;
   static constexpr const char *pyClassName = "DenseBoolArrayAttr";
   static constexpr const char *pyIteratorName = "DenseBoolArrayIterator";
   using PyDenseArrayAttribute::PyDenseArrayAttribute;
 };
 struct PyDenseI8ArrayAttribute

mlir/test/python/ir/attributes.py

 
 @run
 def testDenseArrayGetItem():
     def print_item(attr_asm):
         attr = Attribute.parse(attr_asm)
         print(f"{len(attr)}: {attr[0]}, {attr[1]}")
 
     with Context():
-        # CHECK: 2: 0, 1
+        # CHECK: 2: False, True
         print_item("array<i1: false, true>")
         # CHECK: 2: 2, 3
         print_item("array<i8: 2, 3>")
         # CHECK: 2: 4, 5
         print_item("array<i16: 4, 5>")
         # CHECK: 2: 6, 7
         print_item("array<i32: 6, 7>")
         # CHECK: 2: 8, 9
         print_item("array<i64: 8, 9>")
         # CHECK: 2: 1.{{0+}}, 2.{{0+}}
         print_item("array<f32: 1.0, 2.0>")
         # CHECK: 2: 3.{{0+}}, 4.{{0+}}
         print_item("array<f64: 3.0, 4.0>")
 
+        class MyBool:
+            def __bool__(self):
+                return True
+
+        # CHECK: myboolarray: array<i1: true>
+        print("myboolarray:", DenseBoolArrayAttr.get([MyBool()]))
+
 
 # CHECK-LABEL: TEST: testDenseIntAttrGetItem
 @run
 def testDenseIntAttrGetItem():
     def print_item(attr_asm):
         attr = Attribute.parse(attr_asm)
         dtype = ShapedType(attr.type).element_type
         try: