[mlir][python] Remove __str__ from bindings of StringAttr.

[ingomueller-net]

Summary

This reverts a feature introduced in commit
2a5d497494c24425e99655b85e2277dd3f15a400. The goal of that commit was to
allow StringAttrs to by used transparently wherever Python strs are
expected. But, as the tests in https://reviews.llvm.org/D159182 reveal,
pybind11 doesn't do this conversion based on __str__ automatically,
unlike for the other types introduced in the commit above. At the same
time, changing __str__ breaks the symmetry with other attributes of
print(attr) printing the assembly of the attribute, so the change
probably has more disadvantages than advantages.

[ingomueller-net]

• Rebasing to current main to resolve unrelated CI failures.

[rkayaith]

thanks for following up on this!

[ingomueller-net]

• Rebase to a version from yesterday with working Windows build.

mlir/lib/Bindings/Python/IRAttributes.cpp

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", toPyStr,
-                            "Returns the value of the string attribute");
+    c.def_property_readonly(
+        "value",
+        [](PyStringAttribute &self) {
+          MlirStringRef stringRef = mlirStringAttrGetValue(self);
+          return py::str(stringRef.data, stringRef.length);
+        },
     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/dialects/builtin.py

with Location.unknown(ctx) as loc:
         with InsertionPoint.at_block_begin(m.body):
             f = func.FuncOp(
                 name="some_func",
                 type=FunctionType.get(
                     inputs=[tensor_type, tensor_type], results=[tensor_type]
                 ),
                 visibility="nested",
             )
-            # CHECK: Name is: some_func
+            # CHECK: Name is: "some_func"
             print("Name is: ", f.name)
 
             # CHECK: Type is: (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
             print("Type is: ", f.type)
 
-            # CHECK: Visibility is: nested
+            # CHECK: Visibility is: "nested"
             print("Visibility is: ", f.visibility)
 
             try:
                 entry_block = f.entry_block
             except IndexError as e:
                 # CHECK: External function does not have a body
                 print(e)
 

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: 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_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))
+        # CHECK: sattr value: b'stringattr'
+        print("sattr value:", sattr.value_bytes)
 
         # Test factory methods.
-        # 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: 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-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("stringattr")
-        print("attr:", repr(named.attr))
+        # CHECK: attr: "stringattr"
+        print("attr:", named.attr)
         # CHECK: name: foobar
         print("name:", named.name)
         # CHECK: named: NamedAttribute(foobar="stringattr")
         print("named:", named)
 
 
 # CHECK-LABEL: TEST: testDenseIntAttr
 @run