Use `bytes`, not `str`, to return C++ strings to Python.

[chr1sj0nes]

Summary

str must be valid UTF-8, which is not guaranteed for C++ strings.

[chr1sj0nes]

Use bytes, not str, to return C++ opaque attributes to Python, and add value_bytes for string attributes.

str must be valid UTF-8, which is not guaranteed for C++ strings.

[chr1sj0nes]

Thanks for the review. Please can somebody submit the change? I don't think I have permissions.

mlir/lib/Bindings/Python/DialectTransform.cpp

operationType.def_classmethod(
       "context",
       py::arg("cls"), py::arg("operation_name"),
       py::arg("context") = py::none());
   operationType.def_property_readonly(
       "operation_name",
       [](MlirType type) {
         MlirStringRef operationName =
             mlirTransformOperationTypeGetOperationName(type);
-        return py::str(operationName.data, operationName.length);
+        return py::bytes(operationName.data, operationName.length);
       },
       "Get the name of the payload operation accepted by the handle.");
 }
 
 PYBIND11_MODULE(_mlirDialectsTransform, m) {
   m.doc() = "MLIR Transform dialect.";
   populateDialectTransformSubmodule(m);
 }

mlir/lib/Bindings/Python/IRAttributes.cpp

c.def_static(
           return PyFlatSymbolRefAttribute(context->getRef(), attr);
         },
         py::arg("value"), py::arg("context") = py::none(),
         "Gets a uniqued FlatSymbolRef attribute");
     c.def_property_readonly(
         "value",
         [](PyFlatSymbolRefAttribute &self) {
           MlirStringRef stringRef = mlirFlatSymbolRefAttrGetValue(self);
-          return py::str(stringRef.data, stringRef.length);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the value of the FlatSymbolRef attribute as a string");
+        "Returns the value of the FlatSymbolRef attribute as `bytes`");
   }
 };
 
 class PyOpaqueAttribute : public PyConcreteAttribute<PyOpaqueAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAOpaque;
   static constexpr const char *pyClassName = "OpaqueAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
c.def_static(
           return PyOpaqueAttribute(context->getRef(), attr);
         },
         py::arg("dialect_namespace"), py::arg("buffer"), py::arg("type"),
         py::arg("context") = py::none(), "Gets an Opaque attribute.");
     c.def_property_readonly(
         "dialect_namespace",
         [](PyOpaqueAttribute &self) {
           MlirStringRef stringRef = mlirOpaqueAttrGetDialectNamespace(self);
-          return py::str(stringRef.data, stringRef.length);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the dialect namespace for the Opaque attribute as a string");
+        "Returns the dialect namespace for the Opaque attribute as `bytes`");
     c.def_property_readonly(
         "data",
         [](PyOpaqueAttribute &self) {
           MlirStringRef stringRef = mlirOpaqueAttrGetData(self);
-          return py::str(stringRef.data, stringRef.length);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the data for the Opaqued attributes as a string");
+        "Returns the data for the Opaqued attributes as `bytes`");
   }
 };
 
 class PyStringAttribute : public PyConcreteAttribute<PyStringAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAString;
   static constexpr const char *pyClassName = "StringAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
c.def_static(
           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);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the value of the string attribute");
+        "Returns the value of the string attribute as `bytes`");
   }
 };
 
 // TODO: Support construction of string elements.
 class PyDenseElementsAttribute
     : public PyConcreteAttribute<PyDenseElementsAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseElements;

mlir/lib/Bindings/Python/IRCore.cpp

void mlir::python::populateIRCore(py::module &m) {
   //----------------------------------------------------------------------------
   // Mapping of PyDialectDescriptor
   //----------------------------------------------------------------------------
   py::class_<PyDialectDescriptor>(m, "DialectDescriptor", py::module_local())
       .def_property_readonly("namespace",
                              [](PyDialectDescriptor &self) {
                                MlirStringRef ns =
                                    mlirDialectGetNamespace(self.get());
-                               return py::str(ns.data, ns.length);
+                               return py::bytes(ns.data, ns.length);
                              })
       .def("__repr__", [](PyDialectDescriptor &self) {
         MlirStringRef ns = mlirDialectGetNamespace(self.get());
         std::string repr("<DialectDescriptor ");
         repr.append(ns.data, ns.length);
         repr.append(">");
         return repr;
       });
py::class_<PyOperation, PyOperationBase>(m, "Operation", py::module_local())
                              &PyOperation::getCapsule)
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyOperation::createFromCapsule)
       .def_property_readonly("name",
                              [](PyOperation &self) {
                                self.checkValid();
                                MlirOperation operation = self.get();
                                MlirStringRef name = mlirIdentifierStr(
                                    mlirOperationGetName(operation));
-                               return py::str(name.data, name.length);
+                               return py::bytes(name.data, name.length);
                              })
       .def_property_readonly(
           "context",
           [](PyOperation &self) {
             self.checkValid();
             return self.getContext().getObject();
           },
           "Context that owns the Operation")
void mlir::python::populateIRCore(py::module &m) {
   // Mapping of PyNamedAttribute
   //----------------------------------------------------------------------------
   py::class_<PyNamedAttribute>(m, "NamedAttribute", py::module_local())
       .def("__repr__",
            [](PyNamedAttribute &self) {
              PyPrintAccumulator printAccum;
              printAccum.parts.append("NamedAttribute(");
              printAccum.parts.append(
-                 py::str(mlirIdentifierStr(self.namedAttr.name).data,
+                 py::bytes(mlirIdentifierStr(self.namedAttr.name).data,
                            mlirIdentifierStr(self.namedAttr.name).length));
              printAccum.parts.append("=");
              mlirAttributePrint(self.namedAttr.attribute,
                                 printAccum.getCallback(),
                                 printAccum.getUserData());
              printAccum.parts.append(")");
              return printAccum.join();
            })
       .def_property_readonly(
           "name",
           [](PyNamedAttribute &self) {
-            return py::str(mlirIdentifierStr(self.namedAttr.name).data,
+            return py::bytes(mlirIdentifierStr(self.namedAttr.name).data,
                              mlirIdentifierStr(self.namedAttr.name).length);
           },
           "The name of the NamedAttribute binding")
       .def_property_readonly(
           "attr",
           [](PyNamedAttribute &self) {
             // TODO: When named attribute is removed/refactored, also remove
             // this constructor (it does an inefficient table lookup).
             auto contextRef = PyMlirContext::forContext(

mlir/lib/Bindings/Python/IRTypes.cpp

c.def_static(
         },
         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);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the dialect namespace for the Opaque type as a string.");
+        "Returns the dialect namespace for the Opaque type as `bytes`.");
     c.def_property_readonly(
         "data",
         [](PyOpaqueType &self) {
           MlirStringRef stringRef = mlirOpaqueTypeGetData(self);
-          return py::str(stringRef.data, stringRef.length);
+          return py::bytes(stringRef.data, stringRef.length);
         },
-        "Returns the data for the Opaque type as a string.");
+        "Returns the data for the Opaque type as `bytes`.");
   }
 };
 
 } // namespace
 
 void mlir::python::populateIRTypes(py::module &m) {
   PyIntegerType::bind(m);
   PyIndexType::bind(m);