[mlir] Fix copy-pasted docstrings in Python bindings

[ftynse]

Summary

Docstrings for __str__ method in many classes was recycling the constant
string defined for Type, without being types themselves. Use proper
docstrings instead. Since they are succint, use string literals instead of
top-level constants to avoid further mistakes.

Depends On D89779

[stellaraccident]

Thanks. Believe it or not, I actually read the generic one as correct, thinking 'type' referred to the python class it was attached to. In any case, this is an improvement.

mlir/lib/Bindings/Python/IRModules.cpp

 static const char kOperationStrDunderDocstring[] =
     R"(Prints the assembly form of the operation with default options.
 
 If more advanced control over the assembly formatting or I/O options is needed,
 use the dedicated print method, which supports keyword arguments to customize
 behavior.
 )";
 
-static const char kTypeStrDunderDocstring[] =
-    R"(Prints the assembly form of the type.)";
-
 static const char kDumpDocstring[] =
     R"(Dumps a debug representation of the object to stderr.)";
 
 static const char kAppendBlockDocstring[] =
     R"(Appends a new block, with argument types as positional args.
 
 Returns:
   The created block.
py::class_<PyOperation>(m, "Operation")
           "__str__",
           [](PyOperation &self) {
             self.checkValid();
             PyPrintAccumulator printAccum;
             mlirOperationPrint(self.get(), printAccum.getCallback(),
                                printAccum.getUserData());
             return printAccum.join();
           },
-          kTypeStrDunderDocstring);
+          "Returns the assembly form of the operation.");
 
   // Mapping of PyRegion.
   py::class_<PyRegion>(m, "Region")
       .def_property_readonly(
           "blocks",
           [](PyRegion &self) {
             return PyBlockList(self.getParentOperation(), self.get());
           },
py::class_<PyBlock>(m, "Block")
           "__str__",
           [](PyBlock &self) {
             self.checkValid();
             PyPrintAccumulator printAccum;
             mlirBlockPrint(self.get(), printAccum.getCallback(),
                            printAccum.getUserData());
             return printAccum.join();
           },
-          kTypeStrDunderDocstring);
+          "Returns the assembly form of the block.");
 
-  // Mapping of Type.
+  // Mapping of PyAttribute.
   py::class_<PyAttribute>(m, "Attribute")
       .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(),
py::class_<PyAttribute>(m, "Attribute")
       .def(
           "__str__",
           [](PyAttribute &self) {
             PyPrintAccumulator printAccum;
             mlirAttributePrint(self.attr, printAccum.getCallback(),
                                printAccum.getUserData());
             return printAccum.join();
           },
-          kTypeStrDunderDocstring)
+          "Returns the assembly form of the Attribute.")
       .def("__repr__", [](PyAttribute &self) {
         // Generally, assembly formats are not printed for __repr__ because
         // this can cause exceptionally long debug output and exceptions.
         // However, attribute values are generally considered useful and are
         // printed. This may need to be re-evaluated if debug dumps end up
         // being excessive.
         PyPrintAccumulator printAccum;
         printAccum.parts.append("Attribute(");
void mlir::python::populateIRSubmodule(py::module &m) {
 
   // Standard attribute bindings.
   PyFloatAttribute::bind(m);
   PyIntegerAttribute::bind(m);
   PyBoolAttribute::bind(m);
   PyStringAttribute::bind(m);
   PyDenseElementsAttribute::bind(m);
 
-  // Mapping of Type.
+  // Mapping of PyType.
   py::class_<PyType>(m, "Type")
       .def_property_readonly(
           "context", [](PyType &self) { return self.getContext().getObject(); },
           "Context that owns the Type")
       .def("__eq__",
            [](PyType &self, py::object &other) {
              try {
                PyType otherType = other.cast<PyType>();
                return self == otherType;
              } catch (std::exception &e) {
                return false;
              }
            })
       .def(
           "dump", [](PyType &self) { mlirTypeDump(self.type); }, kDumpDocstring)
       .def(
           "__str__",
           [](PyType &self) {
             PyPrintAccumulator printAccum;
             mlirTypePrint(self.type, printAccum.getCallback(),
                           printAccum.getUserData());
             return printAccum.join();
           },
-          kTypeStrDunderDocstring)
+          "Returns the assembly form of the type.")
       .def("__repr__", [](PyType &self) {
         // Generally, assembly formats are not printed for __repr__ because
         // this can cause exceptionally long debug output and exceptions.
         // However, types are an exception as they typically have compact
         // assembly forms and printing them is useful.
         PyPrintAccumulator printAccum;
         printAccum.parts.append("Type(");
         mlirTypePrint(self.type, printAccum.getCallback(),