Add initial python bindings for attributes.

[stellaraccident]

Summary

• Generic mlir.ir.Attribute class.
• First standard attribute (mlir.ir.StringAttr), following the same pattern as generic vs standard types.
• NamedAttribute class.

[stellaraccident]

ftynse is going offline for a time, so directing this review at Mehdi.

[jpienaar]

Nice

mlir/include/mlir-c/IR.h

339

S/type/attribute/?

mlir/lib/Bindings/Python/IRModules.cpp

159

Throwing vs returning a null? We've mostly returned nulls elsewhere (I have not followed this part of discussion, so perhaps this has been discussed already).

167

What about classTy? Or, as only 3 lines, c.

340

Up to you, but formatv may be more concise

mlir/lib/Bindings/Python/IRModules.h

76

Mmm, I thought the name would be in the MLIR context rather than owned here.

[mehdi_amini]

mlir/lib/Bindings/Python/IRModules.cpp

80

Can you add a class doc?

159

Seems like we associate a semantic of cast (that would assert in C++ land) instead of dyn_cast to these conversion?
It is likely more pythonic to use try: .. block than "check for None after conversion"?

176

Can you add a class doc?

mlir/lib/Bindings/Python/IRModules.h

76

This is a fallout from the C definition of MlirNamedAttribute:

struct MlirNamedAttribute {
  const char *name;
  MlirAttribute attribute;
};

Any chance to make the name here an Identifier instead? That would internalize the string in the context and avoid to have to use this extra management of the unique_ptr<string> done here everywhere where a named attribute will be needed.

[ftynse]

mlir/lib/Bindings/Python/IRModules.cpp

159

Check for None and generally having type polymorphism is arguably ugly in Python. Also requires all type annotations to be Optional[Attribute] instead of just Attribute.

192

Design question: do we want to have "overloads" through type dispatch or do we prefer different function names? (I personally vote for the latter)

338

Let's have a todo to rework these after we expose diagnostic engine in C API

385

get_named for consistency with static constructors above? I see this is not static, but it's still a constructor

mlir/lib/Bindings/Python/IRModules.h

76

I didn't have time to add Identifier to the C API, but it should be straightforward to do. It's the same model as attributes.
Relatedly, we need to discuss how do we model returning a StringRef to context-owned data. I was considering to have a simple struct { const char *, intptr_t }, but StringRef is an LLVM data structure so we may or may not want to put it into LLVM C API.

[stellaraccident]

Address comments.

[stellaraccident]

Thanks for the reviews. I've added a number of TODOs and it doesn't look like there is disagreement on the design points. Feel free to bring them up for further discussion if you feel otherwise.

mlir/lib/Bindings/Python/IRModules.cpp

159

I'm pretty sure we want to throw on a failure to "cast" via constructor invocation like this:

str_attr = StringAttr(ctx.parse_attr("1"))

(note that this castFrom method is not part of the Python API: it only facilitates a downcast within a constructor initializer list)

Relatedly, it is more pythonic for the "default" way of using the API to raise on violation. Many APIs also have an alternative that returns None on failure/not found/etc (ex. dict["foo"] vs dict.get("foo")). I had considered adding explicit cast/dyn_cast/isa methods to follow LLVM conventions, and I think those could be valuable additions, but I left them out of this revision (there are also some fiddly things with the type hierarchy that I need to experiment with). For example, it would be nice to also have methods on Attribute like this:

attr.isa(StringAttr)
attr.cast(StringAttr)
attr.dyn_cast(StringAttr)

Whether or not we do those, I like the "constructor casts" style as a pretty good default that feels reasonable to use, even if it is effectively a short-hand for a future attr.cast(...) call (i.e. it is good form to have a constructor, which then begs the question of what it should do, and this seems reasonable).

167

Changed to cls (here and in PyType).

192

I tried both and prefer the latter as well.

The case becomes stronger when you consider those like PyIntegerType below and I would summarize as "if it is constructing a different kind of attribute or type, it should have a different named static factory function (along with documentation)." This leaves the door open to provide default arguments as sugar, but I prefer for methods that *do* different things to actually be differently named, not rely on magic and hard to describe argument dispatch.

338

Added a TODO to all of the parse_* sites.

340

Thanks, leaving as is since SetPyError takes a Twine.

mlir/lib/Bindings/Python/IRModules.h

76

Agreed - this was quite awkward/bug prone and it would be best if the C-API did do it this way. I added a TODO to rework this to be based on Identifier.

Regarding the related point, for something as basic as a (char*, size), I think it makes sense to have a local struct/calling convention for that. Keep it narrow/local and leave it to the interfacing language to do anything fancy it wants with strings.

I'll attempt to resolve the TODO in a followup for both this and the C-API.

mlir/include/mlir-c/IR.h

 
 /*============================================================================*/
 /* Attribute API.                                                             */
 /*============================================================================*/
 
 /** Parses an attribute. The attribute is owned by the context. */
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr);
 
+/** Checks whether an attribute is null. */
+inline int mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
+
 /** Checks if two attributes are equal. */
 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
 
 /** Prints an attribute by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData);

mlir/lib/Bindings/Python/IRModules.h

public:
   ~PyModule() {
     if (module.ptr)
       mlirModuleDestroy(module);
   }
 
   MlirModule module;
 };
 
+/// Wrapper around the generic MlirAttribute.
+/// The lifetime of a type is bound by the PyContext that created it.
+class PyAttribute {
+public:
+  PyAttribute(MlirAttribute attr) : attr(attr) {}
+  bool operator==(const PyAttribute &other);
+
+  MlirAttribute attr;
+};
+
+/// Represents a Python MlirNamedAttr, carrying an optional owned name.
+/// TODO: Refactor this and the C-API to be based on an Identifier owned
+/// by the context so as to avoid ownership issues here.
+class PyNamedAttribute {
+public:
+  /// Constructs a PyNamedAttr that retains an owned name. This should be
+  /// used in any code that originates an MlirNamedAttribute from a python
+  /// string.
+  /// The lifetime of the PyNamedAttr must extend to the lifetime of the
+  /// passed attribute.
+  PyNamedAttribute(MlirAttribute attr, std::string ownedName);
+
+  MlirNamedAttribute namedAttr;
+
+private:
+  // Since the MlirNamedAttr contains an internal pointer to the actual
+  // memory of the owned string, it must be heap allocated to remain valid.
+  // Otherwise, strings that fit within the small object optimization threshold
+  // will have their memory address change as the containing object is moved,
+  // resulting in an invalid aliased pointer.
+  std::unique_ptr<std::string> ownedName;
+};
+
 /// Wrapper around the generic MlirType.
 /// The lifetime of a type is bound by the PyContext that created it.
 class PyType {
 public:
   PyType(MlirType type) : type(type) {}
   bool operator==(const PyType &other);
 
   MlirType type;
 };
 
 void populateIRSubmodule(pybind11::module &m);
 
 } // namespace python
 } // namespace mlir
 
 #endif // MLIR_BINDINGS_PYTHON_IRMODULES_H

mlir/lib/Bindings/Python/IRModules.cpp

 //===- IRModules.cpp - IR Submodules of pybind module ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IRModules.h"
 #include "PybindUtils.h"
 
+#include "mlir-c/StandardAttributes.h"
 #include "mlir-c/StandardTypes.h"
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
 //------------------------------------------------------------------------------
 // Docstrings (trivial, non-duplicated docstrings are included inline).
struct PyPrintAccumulator {
   }
 
   py::str join() {
     py::str delim("", 0);
     return delim.attr("join")(parts);
   }
 };
 
+/// Accumulates into a python string from a method that is expected to make
+/// one (no more, no less) call to the callback (asserts internally on
+/// violation).
+struct PySinglePartStringAccumulator {
+  void *getUserData() { return this; }
+
+  MlirStringCallback getCallback() {
+    return [](const char *part, intptr_t size, void *userData) {
+      PySinglePartStringAccumulator *accum =
+          static_cast<PySinglePartStringAccumulator *>(userData);
+      assert(!accum->invoked &&
+             "PySinglePartStringAccumulator called back multiple times");
+      accum->invoked = true;
+      accum->value = py::str(part, size);
+    };
+  }
+
+  py::str takeValue() {
+    assert(invoked && "PySinglePartStringAccumulator not called back");
+    return std::move(value);
+  }
+
+private:
+  py::str value;
+  bool invoked = false;
+};
+
 } // namespace
 
 //------------------------------------------------------------------------------
+// PyAttribute.
+//------------------------------------------------------------------------------
+
+bool PyAttribute::operator==(const PyAttribute &other) {
+  return mlirAttributeEqual(attr, other.attr);
+}
+
+//------------------------------------------------------------------------------
+// PyNamedAttribute.
+//------------------------------------------------------------------------------
+
+PyNamedAttribute::PyNamedAttribute(MlirAttribute attr, std::string ownedName)
+    : ownedName(new std::string(std::move(ownedName))) {
+  namedAttr = mlirNamedAttributeGet(this->ownedName->c_str(), attr);
+}
+
+//------------------------------------------------------------------------------
 // PyType.
 //------------------------------------------------------------------------------
 
 bool PyType::operator==(const PyType &other) {
   return mlirTypeEqual(type, other.type);
 }
 
 //------------------------------------------------------------------------------
+// Standard attribute subclasses.
+//------------------------------------------------------------------------------
+
+namespace {
+
+/// CRTP base classes for Python attributes that subclass Attribute and should
+/// be castable from it (i.e. via something like StringAttr(attr)).
+template <typename T>
+class PyConcreteAttribute : public PyAttribute {
+public:
+  // Derived classes must define statics for:
+  //   IsAFunctionTy isaFunction
+  //   const char *pyClassName
+  using ClassTy = py::class_<T, PyAttribute>;
+  using IsAFunctionTy = int (*)(MlirAttribute);
+
+  PyConcreteAttribute() = default;
+  PyConcreteAttribute(MlirAttribute attr) : PyAttribute(attr) {}
+  PyConcreteAttribute(PyAttribute &orig)
+      : PyConcreteAttribute(castFrom(orig)) {}
+
+  static MlirAttribute castFrom(PyAttribute &orig) {
+    if (!T::isaFunction(orig.attr)) {
+      auto origRepr = py::repr(py::cast(orig)).cast<std::string>();
+      throw SetPyError(PyExc_ValueError,
+                       llvm::Twine("Cannot cast attribute to ") +
+                           T::pyClassName + " (from " + origRepr + ")");
+    }
+    return orig.attr;
+  }
+
+  static void bind(py::module &m) {
+    auto cls = ClassTy(m, T::pyClassName);
+    cls.def(py::init<PyAttribute &>(), py::keep_alive<0, 1>());
+    T::bindDerived(cls);
+  }
+
+  /// Implemented by derived classes to add methods to the Python subclass.
+  static void bindDerived(ClassTy &m) {}
+};
+
+class PyStringAttribute : public PyConcreteAttribute<PyStringAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAString;
+  static constexpr const char *pyClassName = "StringAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](PyMlirContext &context, std::string value) {
+          MlirAttribute attr =
+              mlirStringAttrGet(context.context, value.size(), &value[0]);
+          return PyStringAttribute(attr);
+        },
+        py::keep_alive<0, 1>(), "Gets a uniqued string attribute");
+    c.def_static(
+        "get_typed",
+        [](PyType &type, std::string value) {
+          MlirAttribute attr =
+              mlirStringAttrTypedGet(type.type, value.size(), &value[0]);
+          return PyStringAttribute(attr);
+        },
+        py::keep_alive<0, 1>(),
+        "Gets a uniqued string attribute associated to a type");
+    c.def_property_readonly(
+        "value",
+        [](PyStringAttribute &self) {
+          PySinglePartStringAccumulator accum;
+          mlirStringAttrGetValue(self.attr, accum.getCallback(),
+                                 accum.getUserData());
+          return accum.takeValue();
+        },
+        "Returns the value of the string attribute");
+  }
+};
+
+} // namespace
+
+//------------------------------------------------------------------------------
 // Standard type subclasses.
 //------------------------------------------------------------------------------
 
 namespace {
 
 /// CRTP base classes for Python types that subclass Type and should be
 /// castable from it (i.e. via something like IntegerType(t)).
 template <typename T>
if (!T::isaFunction(orig.type)) {
       throw SetPyError(PyExc_ValueError, llvm::Twine("Cannot cast type to ") +
                                              T::pyClassName + " (from " +
                                              origRepr + ")");
     }
     return orig.type;
   }
 
   static void bind(py::module &m) {
-    auto class_ = ClassTy(m, T::pyClassName);
-    class_.def(py::init<PyType &>(), py::keep_alive<0, 1>());
-    T::bindDerived(class_);
+    auto cls = ClassTy(m, T::pyClassName);
+    cls.def(py::init<PyType &>(), py::keep_alive<0, 1>());
+    T::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
 class PyIntegerType : public PyConcreteType<PyIntegerType> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAInteger;
   static constexpr const char *pyClassName = "IntegerType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
-        "signless",
+        "get_signless",
         [](PyMlirContext &context, unsigned width) {
           MlirType t = mlirIntegerTypeGet(context.context, width);
           return PyIntegerType(t);
         },
         py::keep_alive<0, 1>(), "Create a signless integer type");
     c.def_static(
-        "signed",
+        "get_signed",
         [](PyMlirContext &context, unsigned width) {
           MlirType t = mlirIntegerTypeSignedGet(context.context, width);
           return PyIntegerType(t);
         },
         py::keep_alive<0, 1>(), "Create a signed integer type");
     c.def_static(
-        "unsigned",
+        "get_unsigned",
         [](PyMlirContext &context, unsigned width) {
           MlirType t = mlirIntegerTypeUnsignedGet(context.context, width);
           return PyIntegerType(t);
         },
         py::keep_alive<0, 1>(), "Create an unsigned integer type");
     c.def_property_readonly(
         "width",
         [](PyIntegerType &self) { return mlirIntegerTypeGetWidth(self.type); },
void mlir::python::populateIRSubmodule(py::module &m) {
   // Mapping of MlirContext
   py::class_<PyMlirContext>(m, "Context")
       .def(py::init<>())
       .def(
           "parse_module",
           [](PyMlirContext &self, const std::string module) {
             auto moduleRef =
                 mlirModuleCreateParse(self.context, module.c_str());
+            // TODO: Rework error reporting once diagnostic engine is exposed
+            // in C API.
             if (mlirModuleIsNull(moduleRef)) {
               throw SetPyError(
                   PyExc_ValueError,
                   "Unable to parse module assembly (see diagnostics)");
             }
             return PyModule(moduleRef);
           },
           py::keep_alive<0, 1>(), kContextParseDocstring)
       .def(
+          "parse_attr",
+          [](PyMlirContext &self, std::string attrSpec) {
+            MlirAttribute type =
+                mlirAttributeParseGet(self.context, attrSpec.c_str());
+            // TODO: Rework error reporting once diagnostic engine is exposed
+            // in C API.
+            if (mlirAttributeIsNull(type)) {
+              throw SetPyError(PyExc_ValueError,
+                               llvm::Twine("Unable to parse attribute: '") +
+                                   attrSpec + "'");
+            }
+            return PyAttribute(type);
+          },
+          py::keep_alive<0, 1>())
+      .def(
           "parse_type",
           [](PyMlirContext &self, std::string typeSpec) {
             MlirType type = mlirTypeParseGet(self.context, typeSpec.c_str());
+            // TODO: Rework error reporting once diagnostic engine is exposed
+            // in C API.
             if (mlirTypeIsNull(type)) {
               throw SetPyError(PyExc_ValueError,
                                llvm::Twine("Unable to parse type: '") +
                                    typeSpec + "'");
             }
             return PyType(type);
           },
           py::keep_alive<0, 1>(), kContextParseType);
py::class_<PyModule>(m, "Module")
             PyPrintAccumulator printAccum;
             mlirOperationPrint(operation, printAccum.getCallback(),
                                printAccum.getUserData());
             return printAccum.join();
           },
           kOperationStrDunderDocstring);
 
   // Mapping of Type.
+  py::class_<PyAttribute>(m, "Attribute")
+      .def(
+          "get_named",
+          [](PyAttribute &self, std::string name) {
+            return PyNamedAttribute(self.attr, std::move(name));
+          },
+          py::keep_alive<0, 1>(), "Binds a name to the attribute")
+      .def("__eq__",
+           [](PyAttribute &self, py::object &other) {
+             try {
+               PyAttribute otherAttribute = other.cast<PyAttribute>();
+               return self == otherAttribute;
+             } catch (std::exception &e) {
+               return false;
+             }
+           })
+      .def(
+          "dump", [](PyAttribute &self) { mlirAttributeDump(self.attr); },
+          kDumpDocstring)
+      .def(
+          "__str__",
+          [](PyAttribute &self) {
+            PyPrintAccumulator printAccum;
+            mlirAttributePrint(self.attr, printAccum.getCallback(),
+                               printAccum.getUserData());
+            return printAccum.join();
+          },
+          kTypeStrDunderDocstring)
+      .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(");
+        mlirAttributePrint(self.attr, printAccum.getCallback(),
+                           printAccum.getUserData());
+        printAccum.parts.append(")");
+        return printAccum.join();
+      });
+
+  py::class_<PyNamedAttribute>(m, "NamedAttribute")
+      .def("__repr__",
+           [](PyNamedAttribute &self) {
+             PyPrintAccumulator printAccum;
+             printAccum.parts.append("NamedAttribute(");
+             printAccum.parts.append(self.namedAttr.name);
+             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(self.namedAttr.name, strlen(self.namedAttr.name));
+          },
+          "The name of the NamedAttribute binding")
+      .def_property_readonly(
+          "attr",
+          [](PyNamedAttribute &self) {
+            return PyAttribute(self.namedAttr.attribute);
+          },
+          py::keep_alive<0, 1>(),
+          "The underlying generic attribute of the NamedAttribute binding");
+
+  // Standard attribute bindings.
+  PyStringAttribute::bind(m);
+
+  // Mapping of Type.
   py::class_<PyType>(m, "Type")
       .def("__eq__",
            [](PyType &self, py::object &other) {
              try {
                PyType otherType = other.cast<PyType>();
                return self == otherType;
              } catch (std::exception &e) {
                return false;

mlir/lib/Bindings/Python/PybindUtils.h

 
 namespace mlir {
 namespace python {
 
 // Sets a python error, ready to be thrown to return control back to the
 // python runtime.
 // Correct usage:
 //   throw SetPyError(PyExc_ValueError, "Foobar'd");
-pybind11::error_already_set SetPyError(PyObject *excClass, llvm::Twine message);
+pybind11::error_already_set SetPyError(PyObject *excClass,
+                                       const llvm::Twine &message);
 
 } // namespace python
 } // namespace mlir
 
 #endif // MLIR_BINDINGS_PYTHON_PYBINDUTILS_H

mlir/lib/Bindings/Python/PybindUtils.cpp

 //===- PybindUtils.cpp - Utilities for interop with pybind11 --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PybindUtils.h"
 
 namespace py = pybind11;
 
-pybind11::error_already_set mlir::python::SetPyError(PyObject *excClass,
-                                                     llvm::Twine message) {
+pybind11::error_already_set
+mlir::python::SetPyError(PyObject *excClass, const llvm::Twine &message) {
   auto messageStr = message.str();
   PyErr_SetString(excClass, messageStr.c_str());
   return pybind11::error_already_set();
 }

mlir/test/Bindings/Python/ir_attributes.py

+# RUN: %PYTHON %s | FileCheck %s
+
+import mlir
+
+def run(f):
+  print("\nTEST:", f.__name__)
+  f()
+
+
+# CHECK-LABEL: TEST: testParsePrint
+def testParsePrint():
+  ctx = mlir.ir.Context()
+  t = ctx.parse_attr('"hello"')
+  # CHECK: "hello"
+  print(str(t))
+  # CHECK: Attribute("hello")
+  print(repr(t))
+
+run(testParsePrint)
+
+
+# CHECK-LABEL: TEST: testParseError
+# TODO: Hook the diagnostic manager to capture a more meaningful error
+# message.
+def testParseError():
+  ctx = mlir.ir.Context()
+  try:
+    t = ctx.parse_attr("BAD_ATTR_DOES_NOT_EXIST")
+  except ValueError as e:
+    # CHECK: Unable to parse attribute: 'BAD_ATTR_DOES_NOT_EXIST'
+    print("testParseError:", e)
+  else:
+    print("Exception not produced")
+
+run(testParseError)
+
+
+# CHECK-LABEL: TEST: testAttrEq
+def testAttrEq():
+  ctx = mlir.ir.Context()
+  a1 = ctx.parse_attr('"attr1"')
+  a2 = ctx.parse_attr('"attr2"')
+  a3 = ctx.parse_attr('"attr1"')
+  # CHECK: a1 == a1: True
+  print("a1 == a1:", a1 == a1)
+  # CHECK: a1 == a2: False
+  print("a1 == a2:", a1 == a2)
+  # CHECK: a1 == a3: True
+  print("a1 == a3:", a1 == a3)
+  # CHECK: a1 == None: False
+  print("a1 == None:", a1 == None)
+
+run(testAttrEq)
+
+
+# CHECK-LABEL: TEST: testAttrEqDoesNotRaise
+def testAttrEqDoesNotRaise():
+  ctx = mlir.ir.Context()
+  a1 = ctx.parse_attr('"attr1"')
+  not_an_attr = "foo"
+  # CHECK: False
+  print(a1 == not_an_attr)
+  # CHECK: False
+  print(a1 == None)
+  # CHECK: True
+  print(a1 != None)
+
+run(testAttrEqDoesNotRaise)
+
+
+# CHECK-LABEL: TEST: testStandardAttrCasts
+def testStandardAttrCasts():
+  ctx = mlir.ir.Context()
+  a1 = ctx.parse_attr('"attr1"')
+  astr = mlir.ir.StringAttr(a1)
+  aself = mlir.ir.StringAttr(astr)
+  # CHECK: Attribute("attr1")
+  print(repr(astr))
+  try:
+    tillegal = mlir.ir.StringAttr(ctx.parse_attr("1.0"))
+  except ValueError as e:
+    # CHECK: ValueError: Cannot cast attribute to StringAttr (from Attribute(1.000000e+00 : f64))
+    print("ValueError:", e)
+  else:
+    print("Exception not produced")
+
+run(testStandardAttrCasts)
+
+
+# CHECK-LABEL: TEST: testStringAttr
+def testStringAttr():
+  ctx = mlir.ir.Context()
+  sattr = mlir.ir.StringAttr(ctx.parse_attr('"stringattr"'))
+  # CHECK: sattr value: stringattr
+  print("sattr value:", sattr.value)
+
+  # Test factory methods.
+  # CHECK: default_get: "foobar"
+  print("default_get:", mlir.ir.StringAttr.get(ctx, "foobar"))
+  # CHECK: typed_get: "12345" : i32
+  print("typed_get:", mlir.ir.StringAttr.get_typed(
+      mlir.ir.IntegerType.get_signless(ctx, 32), "12345"))
+
+run(testStringAttr)
+
+
+# CHECK-LABEL: TEST: testNamedAttr
+def testNamedAttr():
+  ctx = mlir.ir.Context()
+  a = ctx.parse_attr('"stringattr"')
+  named = a.get_named("foobar")  # Note: under the small object threshold
+  # CHECK: attr: "stringattr"
+  print("attr:", named.attr)
+  # CHECK: name: foobar
+  print("name:", named.name)
+  # CHECK: named: NamedAttribute(foobar="stringattr")
+  print("named:", named)
+
+run(testNamedAttr)

mlir/test/Bindings/Python/ir_types.py

def testIntegerType():
   # CHECK: u32 signless: False
   print("u32 signless:", u32.is_signless)
   # CHECK: u32 signed: False
   print("u32 signed:", u32.is_signed)
   # CHECK: u32 unsigned: True
   print("u32 unsigned:", u32.is_unsigned)
 
   # CHECK: signless: i16
-  print("signless:", mlir.ir.IntegerType.signless(ctx, 16))
+  print("signless:", mlir.ir.IntegerType.get_signless(ctx, 16))
   # CHECK: signed: si8
-  print("signed:", mlir.ir.IntegerType.signed(ctx, 8))
+  print("signed:", mlir.ir.IntegerType.get_signed(ctx, 8))
   # CHECK: unsigned: ui64
-  print("unsigned:", mlir.ir.IntegerType.unsigned(ctx, 64))
+  print("unsigned:", mlir.ir.IntegerType.get_unsigned(ctx, 64))
 
 run(testIntegerType)