[MLIR][python bindings] use pybind C++ APIs for throwing python errors.

[makslevental]

Summary

As per this request https://reviews.llvm.org/D150839#4361048.

[ftynse]

Thanks for the cleanup!

mlir/lib/Bindings/Python/IRAffine.cpp

public:
   PyConcreteAffineExpr(PyMlirContextRef contextRef, MlirAffineExpr affineExpr)
       : BaseTy(std::move(contextRef), affineExpr) {}
   PyConcreteAffineExpr(PyAffineExpr &orig)
       : PyConcreteAffineExpr(orig.getContext(), castFrom(orig)) {}
 
   static MlirAffineExpr castFrom(PyAffineExpr &orig) {
     if (!DerivedTy::isaFunction(orig)) {
       auto origRepr = py::repr(py::cast(orig)).cast<std::string>();
-      throw SetPyError(PyExc_ValueError,
-                       Twine("Cannot cast affine expression to ") +
-                           DerivedTy::pyClassName + " (from " + origRepr + ")");
+      throw py::value_error((Twine("Cannot cast affine expression to ") +
+                             DerivedTy::pyClassName + " (from " + origRepr +
+                             ")")
+                                .str());
     }
     return orig;
   }
 
   static void bind(py::module &m) {
     auto cls = ClassTy(m, DerivedTy::pyClassName, py::module_local());
     cls.def(py::init<PyAffineExpr &>(), py::arg("expr"));
     cls.def_static(

mlir/lib/Bindings/Python/IRAttributes.cpp

 //===- IRAttributes.cpp - Exports builtin and standard attributes ---------===//
 //
 // 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 <utility>
 #include <optional>
+#include <utility>
 
 #include "IRModule.h"
 
 #include "PybindUtils.h"
 
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir-c/BuiltinTypes.h"
 
public:
   static PyDenseElementsAttribute getSplat(const PyType &shapedType,
                                            PyAttribute &elementAttr) {
     auto contextWrapper =
         PyMlirContext::forContext(mlirTypeGetContext(shapedType));
     if (!mlirAttributeIsAInteger(elementAttr) &&
         !mlirAttributeIsAFloat(elementAttr)) {
       std::string message = "Illegal element type for DenseElementsAttr: ";
       message.append(py::repr(py::cast(elementAttr)));
-      throw SetPyError(PyExc_ValueError, message);
+      throw py::value_error(message);
     }
     if (!mlirTypeIsAShaped(shapedType) ||
         !mlirShapedTypeHasStaticShape(shapedType)) {
       std::string message =
           "Expected a static ShapedType for the shaped_type parameter: ";
       message.append(py::repr(py::cast(shapedType)));
-      throw SetPyError(PyExc_ValueError, message);
+      throw py::value_error(message);
     }
     MlirType shapedElementType = mlirShapedTypeGetElementType(shapedType);
     MlirType attrType = mlirAttributeGetType(elementAttr);
     if (!mlirTypeEqual(shapedElementType, attrType)) {
       std::string message =
           "Shaped element type and attribute type must be equal: shaped=";
       message.append(py::repr(py::cast(shapedType)));
       message.append(", element=");
       message.append(py::repr(py::cast(elementAttr)));
-      throw SetPyError(PyExc_ValueError, message);
+      throw py::value_error(message);
     }
 
     MlirAttribute elements =
         mlirDenseElementsAttrSplatGet(shapedType, elementAttr);
     return PyDenseElementsAttribute(contextWrapper->getRef(), elements);
   }
 
   intptr_t dunderLen() { return mlirElementsAttrGetNumElements(*this); }
c.def("__len__", &PyDenseElementsAttribute::dunderLen)
                     "Gets a DenseElementsAttr where all values are the same")
         .def_property_readonly("is_splat",
                                [](PyDenseElementsAttribute &self) -> bool {
                                  return mlirDenseElementsAttrIsSplat(self);
                                })
         .def("get_splat_value",
              [](PyDenseElementsAttribute &self) -> PyAttribute {
                if (!mlirDenseElementsAttrIsSplat(self)) {
-                 throw SetPyError(
-                     PyExc_ValueError,
+                 throw py::value_error(
                      "get_splat_value called on a non-splat attribute");
                }
                return PyAttribute(self.getContext(),
                                   mlirDenseElementsAttrGetSplatValue(self));
              })
         .def_buffer(&PyDenseElementsAttribute::accessBuffer);
   }
 
public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseIntElements;
   static constexpr const char *pyClassName = "DenseIntElementsAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   /// Returns the element at the given linear position. Asserts if the index is
   /// out of range.
   py::int_ dunderGetItem(intptr_t pos) {
     if (pos < 0 || pos >= dunderLen()) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds element");
+      throw py::index_error("attempt to access out of bounds element");
     }
 
     MlirType type = mlirAttributeGetType(*this);
     type = mlirShapedTypeGetElementType(type);
     assert(mlirTypeIsAInteger(type) &&
            "expected integer element type in dense int elements attribute");
     // Dispatch element extraction to an appropriate C function based on the
     // elemental type of the attribute. py::int_ is implicitly constructible
if (isUnsigned) {
       }
       if (width == 32) {
         return mlirDenseElementsAttrGetInt32Value(*this, pos);
       }
       if (width == 64) {
         return mlirDenseElementsAttrGetInt64Value(*this, pos);
       }
     }
-    throw SetPyError(PyExc_TypeError, "Unsupported integer type");
+    throw py::type_error("Unsupported integer type");
   }
 
   static void bindDerived(ClassTy &c) {
     c.def("__getitem__", &PyDenseIntElementsAttribute::dunderGetItem);
   }
 };
 
 class PyDictAttribute : public PyConcreteAttribute<PyDictAttribute> {
c.def_static(
           return PyDictAttribute(context->getRef(), attr);
         },
         py::arg("value") = py::dict(), py::arg("context") = py::none(),
         "Gets an uniqued dict attribute");
     c.def("__getitem__", [](PyDictAttribute &self, const std::string &name) {
       MlirAttribute attr =
           mlirDictionaryAttrGetElementByName(self, toMlirStringRef(name));
       if (mlirAttributeIsNull(attr)) {
-        throw SetPyError(PyExc_KeyError,
-                         "attempt to access a non-existent attribute");
+        throw py::key_error("attempt to access a non-existent attribute");
       }
       return PyAttribute(self.getContext(), attr);
     });
     c.def("__getitem__", [](PyDictAttribute &self, intptr_t index) {
       if (index < 0 || index >= self.dunderLen()) {
-        throw SetPyError(PyExc_IndexError,
-                         "attempt to access out of bounds attribute");
+        throw py::index_error("attempt to access out of bounds attribute");
       }
       MlirNamedAttribute namedAttr = mlirDictionaryAttrGetElement(self, index);
       return PyNamedAttribute(
           namedAttr.attribute,
           std::string(mlirIdentifierStr(namedAttr.name).data));
     });
   }
 };
 
 /// Refinement of PyDenseElementsAttribute for attributes containing
 /// floating-point values. Supports element access.
 class PyDenseFPElementsAttribute
     : public PyConcreteAttribute<PyDenseFPElementsAttribute,
                                  PyDenseElementsAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsADenseFPElements;
   static constexpr const char *pyClassName = "DenseFPElementsAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   py::float_ dunderGetItem(intptr_t pos) {
     if (pos < 0 || pos >= dunderLen()) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds element");
+      throw py::index_error("attempt to access out of bounds element");
     }
 
     MlirType type = mlirAttributeGetType(*this);
     type = mlirShapedTypeGetElementType(type);
     // Dispatch element extraction to an appropriate C function based on the
     // elemental type of the attribute. py::float_ is implicitly constructible
     // from float and double.
     // TODO: consider caching the type properties in the constructor to avoid
     // querying them on each element access.
     if (mlirTypeIsAF32(type)) {
       return mlirDenseElementsAttrGetFloatValue(*this, pos);
     }
     if (mlirTypeIsAF64(type)) {
       return mlirDenseElementsAttrGetDoubleValue(*this, pos);
     }
-    throw SetPyError(PyExc_TypeError, "Unsupported floating-point type");
+    throw py::type_error("Unsupported floating-point type");
   }
 
   static void bindDerived(ClassTy &c) {
     c.def("__getitem__", &PyDenseFPElementsAttribute::dunderGetItem);
   }
 };
 
 class PyTypeAttribute : public PyConcreteAttribute<PyTypeAttribute> {

mlir/lib/Bindings/Python/IRCore.cpp

public:
   intptr_t dunderLen() {
     operation->checkValid();
     return mlirOperationGetNumRegions(operation->get());
   }
 
   PyRegion dunderGetItem(intptr_t index) {
     // dunderLen checks validity.
     if (index < 0 || index >= dunderLen()) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds region");
+      throw py::index_error("attempt to access out of bounds region");
     }
     MlirRegion region = mlirOperationGetRegion(operation->get(), index);
     return PyRegion(operation, region);
   }
 
   static void bind(py::module &m) {
     py::class_<PyRegionList>(m, "RegionSequence", py::module_local())
         .def("__len__", &PyRegionList::dunderLen)
while (!mlirBlockIsNull(block)) {
       block = mlirBlockGetNextInRegion(block);
     }
     return count;
   }
 
   PyBlock dunderGetItem(intptr_t index) {
     operation->checkValid();
     if (index < 0) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds block");
+      throw py::index_error("attempt to access out of bounds block");
     }
     MlirBlock block = mlirRegionGetFirstBlock(region);
     while (!mlirBlockIsNull(block)) {
       if (index == 0) {
         return PyBlock(operation, block);
       }
       block = mlirBlockGetNextInRegion(block);
       index -= 1;
     }
-    throw SetPyError(PyExc_IndexError, "attempt to access out of bounds block");
+    throw py::index_error("attempt to access out of bounds block");
   }
 
   PyBlock appendBlock(const py::args &pyArgTypes) {
     operation->checkValid();
     llvm::SmallVector<MlirType, 4> argTypes;
     llvm::SmallVector<MlirLocation, 4> argLocs;
     argTypes.reserve(pyArgTypes.size());
     argLocs.reserve(pyArgTypes.size());
while (!mlirOperationIsNull(childOp)) {
       childOp = mlirOperationGetNextInBlock(childOp);
     }
     return count;
   }
 
   py::object dunderGetItem(intptr_t index) {
     parentOperation->checkValid();
     if (index < 0) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds operation");
+      throw py::index_error("attempt to access out of bounds operation");
     }
     MlirOperation childOp = mlirBlockGetFirstOperation(block);
     while (!mlirOperationIsNull(childOp)) {
       if (index == 0) {
         return PyOperation::forOperation(parentOperation->getContext(), childOp)
             ->createOpView();
       }
       childOp = mlirOperationGetNextInBlock(childOp);
       index -= 1;
     }
-    throw SetPyError(PyExc_IndexError,
-                     "attempt to access out of bounds operation");
+    throw py::index_error("attempt to access out of bounds operation");
   }
 
   static void bind(py::module &m) {
     py::class_<PyOperationList>(m, "OperationList", py::module_local())
         .def("__getitem__", &PyOperationList::dunderGetItem)
         .def("__iter__", &PyOperationList::dunderIter)
         .def("__len__", &PyOperationList::dunderLen);
   }
MlirLogicalResult PyMlirContext::ErrorCapture::handler(MlirDiagnostic diag,
 
   self->errors.emplace_back(PyDiagnostic(diag).getInfo());
   return mlirLogicalResultSuccess();
 }
 
 PyMlirContext &DefaultingPyMlirContext::resolve() {
   PyMlirContext *context = PyThreadContextEntry::getDefaultContext();
   if (!context) {
-    throw SetPyError(
-        PyExc_RuntimeError,
+    throw std::runtime_error(
         "An MLIR function requires a Context but none was provided in the call "
         "or from the surrounding environment. Either pass to the function with "
         "a 'context=' argument or establish a default using 'with Context():'");
   }
   return *context;
 }
 
 //------------------------------------------------------------------------------
push(FrameKind::Context, /*context=*/contextObj,
        /*insertionPoint=*/py::object(),
        /*location=*/py::object());
   return contextObj;
 }
 
 void PyThreadContextEntry::popContext(PyMlirContext &context) {
   auto &stack = getStack();
   if (stack.empty())
-    throw SetPyError(PyExc_RuntimeError, "Unbalanced Context enter/exit");
+    throw std::runtime_error("Unbalanced Context enter/exit");
   auto &tos = stack.back();
   if (tos.frameKind != FrameKind::Context && tos.getContext() != &context)
-    throw SetPyError(PyExc_RuntimeError, "Unbalanced Context enter/exit");
+    throw std::runtime_error("Unbalanced Context enter/exit");
   stack.pop_back();
 }
 
 py::object
 PyThreadContextEntry::pushInsertionPoint(PyInsertionPoint &insertionPoint) {
   py::object contextObj =
       insertionPoint.getBlock().getParentOperation()->getContext().getObject();
   py::object insertionPointObj = py::cast(insertionPoint);
   push(FrameKind::InsertionPoint,
        /*context=*/contextObj,
        /*insertionPoint=*/insertionPointObj,
        /*location=*/py::object());
   return insertionPointObj;
 }
 
 void PyThreadContextEntry::popInsertionPoint(PyInsertionPoint &insertionPoint) {
   auto &stack = getStack();
   if (stack.empty())
-    throw SetPyError(PyExc_RuntimeError,
-                     "Unbalanced InsertionPoint enter/exit");
+    throw std::runtime_error("Unbalanced InsertionPoint enter/exit");
   auto &tos = stack.back();
   if (tos.frameKind != FrameKind::InsertionPoint &&
       tos.getInsertionPoint() != &insertionPoint)
-    throw SetPyError(PyExc_RuntimeError,
-                     "Unbalanced InsertionPoint enter/exit");
+    throw std::runtime_error("Unbalanced InsertionPoint enter/exit");
   stack.pop_back();
 }
 
 py::object PyThreadContextEntry::pushLocation(PyLocation &location) {
   py::object contextObj = location.getContext().getObject();
   py::object locationObj = py::cast(location);
   push(FrameKind::Location, /*context=*/contextObj,
        /*insertionPoint=*/py::object(),
        /*location=*/locationObj);
   return locationObj;
 }
 
 void PyThreadContextEntry::popLocation(PyLocation &location) {
   auto &stack = getStack();
   if (stack.empty())
-    throw SetPyError(PyExc_RuntimeError, "Unbalanced Location enter/exit");
+    throw std::runtime_error("Unbalanced Location enter/exit");
   auto &tos = stack.back();
   if (tos.frameKind != FrameKind::Location && tos.getLocation() != &location)
-    throw SetPyError(PyExc_RuntimeError, "Unbalanced Location enter/exit");
+    throw std::runtime_error("Unbalanced Location enter/exit");
   stack.pop_back();
 }
 
 //------------------------------------------------------------------------------
 // PyDiagnostic*
 //------------------------------------------------------------------------------
 
 void PyDiagnostic::invalidate() {

 // PyDialect, PyDialectDescriptor, PyDialects, PyDialectRegistry
 //------------------------------------------------------------------------------
 
 MlirDialect PyDialects::getDialectForKey(const std::string &key,
                                          bool attrError) {
   MlirDialect dialect = mlirContextGetOrLoadDialect(getContext()->get(),
                                                     {key.data(), key.size()});
   if (mlirDialectIsNull(dialect)) {
-    throw SetPyError(attrError ? PyExc_AttributeError : PyExc_IndexError,
-                     Twine("Dialect '") + key + "' not found");
+    std::string msg = (Twine("Dialect '") + key + "' not found").str();
+    if (attrError)
+      throw py::attribute_error(msg);
+    else
+      throw py::index_error(msg);
   }
   return dialect;
 }
 
 py::object PyDialectRegistry::getCapsule() {
   return py::reinterpret_steal<py::object>(
       mlirPythonDialectRegistryToCapsule(*this));
 }
void PyLocation::contextExit(const pybind11::object &excType,
                              const pybind11::object &excVal,
                              const pybind11::object &excTb) {
   PyThreadContextEntry::popLocation(*this);
 }
 
 PyLocation &DefaultingPyLocation::resolve() {
   auto *location = PyThreadContextEntry::getDefaultLocation();
   if (!location) {
-    throw SetPyError(
-        PyExc_RuntimeError,
+    throw std::runtime_error(
         "An MLIR function requires a Location but none was provided in the "
         "call or from the surrounding environment. Either pass to the function "
         "with a 'loc=' argument or establish a default using 'with loc:'");
   }
   return *location;
 }
 
 //------------------------------------------------------------------------------
MlirOperation op =
                                toMlirStringRef(sourceName));
   if (mlirOperationIsNull(op))
     throw MLIRError("Unable to parse operation assembly", errors.take());
   return PyOperation::createDetached(std::move(contextRef), op);
 }
 
 void PyOperation::checkValid() const {
   if (!valid) {
-    throw SetPyError(PyExc_RuntimeError, "the operation has been invalidated");
+    throw std::runtime_error("the operation has been invalidated");
   }
 }
 
 void PyOperationBase::print(py::object fileObject, bool binary,
                             std::optional<int64_t> largeElementsLimit,
                             bool enableDebugInfo, bool prettyDebugInfo,
                             bool printGenericOpForm, bool useLocalScope,
                             bool assumeVerified) {
bool PyOperationBase::verify() {
   if (!mlirOperationVerify(op.get()))
     throw MLIRError("Verification failed", errors.take());
   return true;
 }
 
 std::optional<PyOperationRef> PyOperation::getParentOperation() {
   checkValid();
   if (!isAttached())
-    throw SetPyError(PyExc_ValueError, "Detached operations have no parent");
+    throw py::value_error("Detached operations have no parent");
   MlirOperation operation = mlirOperationGetParentOperation(get());
   if (mlirOperationIsNull(operation))
     return {};
   return PyOperation::forOperation(getContext(), operation);
 }
 
 PyBlock PyOperation::getBlock() {
   checkValid();
py::object PyOperation::create(const std::string &name,
                                const py::object &maybeIp) {
   llvm::SmallVector<MlirValue, 4> mlirOperands;
   llvm::SmallVector<MlirType, 4> mlirResults;
   llvm::SmallVector<MlirBlock, 4> mlirSuccessors;
   llvm::SmallVector<std::pair<std::string, MlirAttribute>, 4> mlirAttributes;
 
   // General parameter validation.
   if (regions < 0)
-    throw SetPyError(PyExc_ValueError, "number of regions must be >= 0");
+    throw py::value_error("number of regions must be >= 0");
 
   // Unpack/validate operands.
   if (operands) {
     mlirOperands.reserve(operands->size());
     for (PyValue *operand : *operands) {
       if (!operand)
-        throw SetPyError(PyExc_ValueError, "operand value cannot be None");
+        throw py::value_error("operand value cannot be None");
       mlirOperands.push_back(operand->get());
     }
   }
 
   // Unpack/validate results.
   if (results) {
     mlirResults.reserve(results->size());
     for (PyType *result : *results) {
       // TODO: Verify result type originate from the same context.
       if (!result)
-        throw SetPyError(PyExc_ValueError, "result type cannot be None");
+        throw py::value_error("result type cannot be None");
       mlirResults.push_back(*result);
     }
   }
   // Unpack/validate attributes.
   if (attributes) {
     mlirAttributes.reserve(attributes->size());
     for (auto &it : *attributes) {
       std::string key;
if (attributes) {
     }
   }
   // Unpack/validate successors.
   if (successors) {
     mlirSuccessors.reserve(successors->size());
     for (auto *successor : *successors) {
       // TODO: Verify successor originate from the same context.
       if (!successor)
-        throw SetPyError(PyExc_ValueError, "successor block cannot be None");
+        throw py::value_error("successor block cannot be None");
       mlirSuccessors.push_back(successor->get());
     }
   }
 
   // Apply unpacked/validated to the operation state. Beyond this
   // point, exceptions cannot be thrown or else the state will leak.
   MlirOperationState state =
       mlirOperationStateGet(toMlirStringRef(name), location);

 
 PyInsertionPoint::PyInsertionPoint(PyOperationBase &beforeOperationBase)
     : refOperation(beforeOperationBase.getOperation().getRef()),
       block((*refOperation)->getBlock()) {}
 
 void PyInsertionPoint::insert(PyOperationBase &operationBase) {
   PyOperation &operation = operationBase.getOperation();
   if (operation.isAttached())
-    throw SetPyError(PyExc_ValueError,
-                     "Attempt to insert operation that is already attached");
+    throw py::value_error(
   block.getParentOperation()->checkValid();
   MlirOperation beforeOp = {nullptr};
   if (refOperation) {
     // Insert before operation.
     (*refOperation)->checkValid();
     beforeOp = (*refOperation)->get();
   } else {
     // Insert at end (before null) is only valid if the block does not
PyInsertionPoint PyInsertionPoint::atBlockBegin(PyBlock &block) {
   PyOperationRef firstOpRef = PyOperation::forOperation(
       block.getParentOperation()->getContext(), firstOp);
   return PyInsertionPoint{block, std::move(firstOpRef)};
 }
 
 PyInsertionPoint PyInsertionPoint::atBlockTerminator(PyBlock &block) {
   MlirOperation terminator = mlirBlockGetTerminator(block.get());
   if (mlirOperationIsNull(terminator))
-    throw SetPyError(PyExc_ValueError, "Block has no terminator");
+    throw py::value_error("Block has no terminator");
   PyOperationRef terminatorOpRef = PyOperation::forOperation(
       block.getParentOperation()->getContext(), terminator);
   return PyInsertionPoint{block, std::move(terminatorOpRef)};
 }
 
 py::object PyInsertionPoint::contextEnter() {
   return PyThreadContextEntry::pushInsertionPoint(*this);
 }
public:
   PyConcreteValue(PyValue &orig)
       : PyConcreteValue(orig.getParentOperation(), castFrom(orig)) {}
 
   /// Attempts to cast the original value to the derived type and throws on
   /// type mismatches.
   static MlirValue castFrom(PyValue &orig) {
     if (!DerivedTy::isaFunction(orig.get())) {
       auto origRepr = py::repr(py::cast(orig)).cast<std::string>();
-      throw SetPyError(PyExc_ValueError, Twine("Cannot cast value to ") +
-                                             DerivedTy::pyClassName +
-                                             " (from " + origRepr + ")");
+      throw py::value_error((Twine("Cannot cast value to ") +
+                             DerivedTy::pyClassName + " (from " + origRepr +
+                             ")")
+                                .str());
     }
     return orig.get();
   }
 
   /// Binds the Python module objects to functions of this class.
   static void bind(py::module &m) {
     auto cls = ClassTy(m, DerivedTy::pyClassName, py::module_local());
     cls.def(py::init<PyValue &>(), py::keep_alive<0, 1>(), py::arg("value"));

 public:
   PyOpAttributeMap(PyOperationRef operation)
       : operation(std::move(operation)) {}
 
   PyAttribute dunderGetItemNamed(const std::string &name) {
     MlirAttribute attr = mlirOperationGetAttributeByName(operation->get(),
                                                          toMlirStringRef(name));
     if (mlirAttributeIsNull(attr)) {
-      throw SetPyError(PyExc_KeyError,
-                       "attempt to access a non-existent attribute");
+      throw py::key_error("attempt to access a non-existent attribute");
     }
     return PyAttribute(operation->getContext(), attr);
   }
 
   PyNamedAttribute dunderGetItemIndexed(intptr_t index) {
     if (index < 0 || index >= dunderLen()) {
-      throw SetPyError(PyExc_IndexError,
-                       "attempt to access out of bounds attribute");
+      throw py::index_error("attempt to access out of bounds attribute");
     }
     MlirNamedAttribute namedAttr =
         mlirOperationGetAttribute(operation->get(), index);
     return PyNamedAttribute(
         namedAttr.attribute,
         std::string(mlirIdentifierStr(namedAttr.name).data,
                     mlirIdentifierStr(namedAttr.name).length));
   }
 
   void dunderSetItem(const std::string &name, const PyAttribute &attr) {
     mlirOperationSetAttributeByName(operation->get(), toMlirStringRef(name),
                                     attr);
   }
 
   void dunderDelItem(const std::string &name) {
     int removed = mlirOperationRemoveAttributeByName(operation->get(),
                                                      toMlirStringRef(name));
     if (!removed)
-      throw SetPyError(PyExc_KeyError,
-                       "attempt to delete a non-existent attribute");
+      throw py::key_error("attempt to delete a non-existent attribute");
   }
 
   intptr_t dunderLen() {
     return mlirOperationGetNumAttributes(operation->get());
   }
 
   bool dunderContains(const std::string &name) {
     return !mlirAttributeIsNull(mlirOperationGetAttributeByName(
py::class_<PyMlirContext>(m, "_BaseContext", py::module_local())
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyMlirContext::createFromCapsule)
       .def("__enter__", &PyMlirContext::contextEnter)
       .def("__exit__", &PyMlirContext::contextExit)
       .def_property_readonly_static(
           "current",
           [](py::object & /*class*/) {
             auto *context = PyThreadContextEntry::getDefaultContext();
             if (!context)
-              throw SetPyError(PyExc_ValueError, "No current Context");
+              throw py::value_error("No current Context");
             return context;
           },
           "Gets the Context bound to the current thread or raises ValueError")
       .def_property_readonly(
           "dialects",
           [](PyMlirContext &self) { return PyDialects(self.getRef()); },
           "Gets a container for accessing dialects by name")
       .def_property_readonly(
           "d", [](PyMlirContext &self) { return PyDialects(self.getRef()); },
           "Alias for 'dialect'")
       .def(
           "get_dialect_descriptor",
           [=](PyMlirContext &self, std::string &name) {
             MlirDialect dialect = mlirContextGetOrLoadDialect(
                 self.get(), {name.data(), name.size()});
             if (mlirDialectIsNull(dialect)) {
-              throw SetPyError(PyExc_ValueError,
-                               Twine("Dialect '") + name + "' not found");
+              throw py::value_error(
+                  (Twine("Dialect '") + name + "' not found").str());
             }
             return PyDialectDescriptor(self.getRef(), dialect);
           },
           py::arg("dialect_name"),
           "Gets or loads a dialect by name, returning its descriptor object")
       .def_property(
           "allow_unregistered_dialects",
           [](PyMlirContext &self) -> bool {
py::class_<PyLocation>(m, "Location", py::module_local())
              return mlirLocationEqual(self, other);
            })
       .def("__eq__", [](PyLocation &self, py::object other) { return false; })
       .def_property_readonly_static(
           "current",
           [](py::object & /*class*/) {
             auto *loc = PyThreadContextEntry::getDefaultLocation();
             if (!loc)
-              throw SetPyError(PyExc_ValueError, "No current Location");
+              throw py::value_error("No current Location");
             return loc;
           },
           "Gets the Location bound to the current thread or raises ValueError")
       .def_static(
           "unknown",
           [](DefaultingPyMlirContext context) {
             return PyLocation(context->getRef(),
                               mlirLocationUnknownGet(context->get()));
py::class_<PyOperationBase>(m, "_OperationBase", py::module_local())
           "Returns the list of Operation results.")
       .def_property_readonly(
           "result",
           [](PyOperationBase &self) {
             auto &operation = self.getOperation();
             auto numResults = mlirOperationGetNumResults(operation);
             if (numResults != 1) {
               auto name = mlirIdentifierStr(mlirOperationGetName(operation));
-              throw SetPyError(
-                  PyExc_ValueError,
-                  Twine("Cannot call .result on operation ") +
-                      StringRef(name.data, name.length) + " which has " +
-                      Twine(numResults) +
-                      " results (it is only valid for operations with a "
-                      "single result)");
+              throw py::value_error(
+                  (Twine("Cannot call .result on operation ") +
+                   "single result)")
+                      .str());
             }
             return PyOpResult(operation.getRef(),
                               mlirOperationGetResult(operation, 0));
           },
           "Shortcut to get an op result if it has only one (throws an error "
           "otherwise).")
       .def_property_readonly(
           "location",
py::class_<PyInsertionPoint>(m, "InsertionPoint", py::module_local())
            "Inserts after the last operation but still inside the block.")
       .def("__enter__", &PyInsertionPoint::contextEnter)
       .def("__exit__", &PyInsertionPoint::contextExit)
       .def_property_readonly_static(
           "current",
           [](py::object & /*class*/) {
             auto *ip = PyThreadContextEntry::getDefaultInsertionPoint();
             if (!ip)
-              throw SetPyError(PyExc_ValueError, "No current InsertionPoint");
+              throw py::value_error("No current InsertionPoint");
             return ip;
           },
           "Gets the InsertionPoint bound to the current thread or raises "
           "ValueError if none has been set")
       .def(py::init<PyOperationBase &>(), py::arg("beforeOperation"),
            "Inserts before a referenced operation.")
       .def_static("at_block_begin", &PyInsertionPoint::atBlockBegin,
                   py::arg("block"), "Inserts at the beginning of the block.")

mlir/lib/Bindings/Python/IRModule.h

PyConcreteType(PyMlirContextRef contextRef, MlirType t)
     pybind11::implicitly_convertible<PyType, DerivedTy>();
   }
   PyConcreteType(PyType &orig)
       : PyConcreteType(orig.getContext(), castFrom(orig)) {}
 
   static MlirType castFrom(PyType &orig) {
     if (!DerivedTy::isaFunction(orig)) {
       auto origRepr = pybind11::repr(pybind11::cast(orig)).cast<std::string>();
-      throw SetPyError(PyExc_ValueError, llvm::Twine("Cannot cast type to ") +
-                                             DerivedTy::pyClassName +
-                                             " (from " + origRepr + ")");
+      throw py::value_error((llvm::Twine("Cannot cast type to ") +
+                             DerivedTy::pyClassName + " (from " + origRepr +
+                             ")")
+                                .str());
     }
     return orig;
   }
 
   static void bind(pybind11::module &m) {
     auto cls = ClassTy(m, DerivedTy::pyClassName, pybind11::module_local());
     cls.def(pybind11::init<PyType &>(), pybind11::keep_alive<0, 1>(),
             pybind11::arg("cast_from_type"));
     cls.def_static(
         "isinstance",
         [](PyType &otherType) -> bool {
           return DerivedTy::isaFunction(otherType);
         },
         pybind11::arg("other"));
     cls.def_property_readonly_static(
         "static_typeid", [](py::object & /*class*/) -> MlirTypeID {
           if (DerivedTy::getTypeIdFunction)
             return DerivedTy::getTypeIdFunction();
-          throw SetPyError(PyExc_AttributeError,
-                           DerivedTy::pyClassName +
-                               llvm::Twine(" has no typeid."));
+          throw py::attribute_error(
+              (DerivedTy::pyClassName + llvm::Twine(" has no typeid.")).str());
         });
     cls.def_property_readonly("typeid", [](PyType &self) {
       return py::cast(self).attr("typeid").cast<MlirTypeID>();
     });
     cls.def("__repr__", [](DerivedTy &self) {
       PyPrintAccumulator printAccum;
       printAccum.parts.append(DerivedTy::pyClassName);
       printAccum.parts.append("(");
public:
   PyConcreteAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
       : BaseTy(std::move(contextRef), attr) {}
   PyConcreteAttribute(PyAttribute &orig)
       : PyConcreteAttribute(orig.getContext(), castFrom(orig)) {}
 
   static MlirAttribute castFrom(PyAttribute &orig) {
     if (!DerivedTy::isaFunction(orig)) {
       auto origRepr = pybind11::repr(pybind11::cast(orig)).cast<std::string>();
-      throw SetPyError(PyExc_ValueError,
-                       llvm::Twine("Cannot cast attribute to ") +
-                           DerivedTy::pyClassName + " (from " + origRepr + ")");
+      throw py::value_error((llvm::Twine("Cannot cast attribute to ") +
+                             DerivedTy::pyClassName + " (from " + origRepr +
+                             ")")
+                                .str());
     }
     return orig;
   }
 
   static void bind(pybind11::module &m) {
     auto cls = ClassTy(m, DerivedTy::pyClassName, pybind11::buffer_protocol(),
                        pybind11::module_local());
     cls.def(pybind11::init<PyAttribute &>(), pybind11::keep_alive<0, 1>(),

mlir/lib/Bindings/Python/IRModule.cpp

 //===- IRModule.cpp - IR 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 "IRModule.h"
 #include "Globals.h"
 #include "PybindUtils.h"
 
-#include <vector>
 #include <optional>
+#include <vector>
 
 #include "mlir-c/Bindings/Python/Interop.h"
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
 // -----------------------------------------------------------------------------
void PyGlobals::registerAttributeBuilder(const std::string &attributeKind,
   }
   found = std::move(pyFunc);
 }
 
 void PyGlobals::registerDialectImpl(const std::string &dialectNamespace,
                                     py::object pyClass) {
   py::object &found = dialectClassMap[dialectNamespace];
   if (found) {
-    throw SetPyError(PyExc_RuntimeError, llvm::Twine("Dialect namespace '") +
-                                             dialectNamespace +
-                                             "' is already registered.");
+    throw std::runtime_error((llvm::Twine("Dialect namespace '") +
+                              dialectNamespace + "' is already registered.")
+                                 .str());
   }
   found = std::move(pyClass);
 }
 
 void PyGlobals::registerOperationImpl(const std::string &operationName,
                                       py::object pyClass) {
   py::object &found = operationClassMap[operationName];
   if (found) {
-    throw SetPyError(PyExc_RuntimeError, llvm::Twine("Operation '") +
-                                             operationName +
-                                             "' is already registered.");
+    throw std::runtime_error((llvm::Twine("Operation '") + operationName +
+                              "' is already registered.")
+                                 .str());
   }
   found = std::move(pyClass);
 }
 
 std::optional<py::function>
 PyGlobals::lookupAttributeBuilder(const std::string &attributeKind) {
   // Fast match against the class map first (common case).
   const auto foundIt = attributeBuilderMap.find(attributeKind);

mlir/lib/Bindings/Python/IRTypes.cpp

static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](PyType &elementType) {
           // The element must be a floating point or integer scalar type.
           if (mlirTypeIsAIntegerOrFloat(elementType)) {
             MlirType t = mlirComplexTypeGet(elementType);
             return PyComplexType(elementType.getContext(), t);
           }
-          throw SetPyError(
-              PyExc_ValueError,
-              Twine("invalid '") +
-                  py::repr(py::cast(elementType)).cast<std::string>() +
-                  "' and expected floating point or integer type.");
+          throw py::value_error(
+              (Twine("invalid '") +
+               "' and expected floating point or integer type.")
+                  .str());
         },
         "Create a complex type");
     c.def_property_readonly(
         "element_type",
         [](PyComplexType &self) -> PyType {
           MlirType t = mlirComplexTypeGetElementType(self);
           return PyType(self.getContext(), t);
         },
c.def_static(
         []() { return mlirShapedTypeGetDynamicStrideOrOffset(); },
         "Returns the value used to indicate dynamic strides or offsets in "
         "shaped types.");
   }
 
 private:
   void requireHasRank() {
     if (!mlirShapedTypeHasRank(*this)) {
-      throw SetPyError(
-          PyExc_ValueError,
+      throw py::value_error(
           "calling this method requires that the type has a rank.");
     }
   }
 };
 
 /// Vector Type subclass - VectorType.
 class PyVectorType : public PyConcreteType<PyVectorType, PyShapedType> {
 public:

mlir/lib/Bindings/Python/Pass.cpp

py::class_<PyPassManager>(m, "PassManager", py::module_local())
           [](const std::string &pipeline, DefaultingPyMlirContext context) {
             MlirPassManager passManager = mlirPassManagerCreate(context->get());
             PyPrintAccumulator errorMsg;
             MlirLogicalResult status = mlirParsePassPipeline(
                 mlirPassManagerGetAsOpPassManager(passManager),
                 mlirStringRefCreate(pipeline.data(), pipeline.size()),
                 errorMsg.getCallback(), errorMsg.getUserData());
             if (mlirLogicalResultIsFailure(status))
-              throw SetPyError(PyExc_ValueError, std::string(errorMsg.join()));
+              throw py::value_error(std::string(errorMsg.join()));
             return new PyPassManager(passManager);
           },
           py::arg("pipeline"), py::arg("context") = py::none(),
           "Parse a textual pass-pipeline and return a top-level PassManager "
           "that can be applied on a Module. Throw a ValueError if the pipeline "
           "can't be parsed")
       .def(
           "add",
           [](PyPassManager &passManager, const std::string &pipeline) {
             PyPrintAccumulator errorMsg;
             MlirLogicalResult status = mlirOpPassManagerAddPipeline(
                 mlirPassManagerGetAsOpPassManager(passManager.get()),
                 mlirStringRefCreate(pipeline.data(), pipeline.size()),
                 errorMsg.getCallback(), errorMsg.getUserData());
             if (mlirLogicalResultIsFailure(status))
-              throw SetPyError(PyExc_ValueError, std::string(errorMsg.join()));
+              throw py::value_error(std::string(errorMsg.join()));
           },
           py::arg("pipeline"),
           "Add textual pipeline elements to the pass manager. Throws a "
           "ValueError if the pipeline can't be parsed.")
       .def(
           "run",
           [](PyPassManager &passManager, PyOperationBase &op) {
             PyMlirContext::ErrorCapture errors(op.getOperation().getContext());

mlir/lib/Bindings/Python/PybindUtils.h

 #include "llvm/Support/DataTypes.h"
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.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,
-                                       const llvm::Twine &message);
-
 /// CRTP template for special wrapper types that are allowed to be passed in as
 /// 'None' function arguments and can be resolved by some global mechanic if
 /// so. Such types will raise an error if this global resolution fails, and
 /// it is actually illegal for them to ever be unresolved. From a user
 /// perspective, they behave like a smart ptr to the underlying type (i.e.
 /// 'get' method and operator-> overloaded).
 ///
 /// Derived types must provide a method, which is called when an environmental

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"
-
-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/python/CMakeLists.txt

declare_mlir_python_extension(MLIRPythonExtension.Core
   SOURCES
     MainModule.cpp
     IRAffine.cpp
     IRAttributes.cpp
     IRCore.cpp
     IRInterfaces.cpp
     IRModule.cpp
     IRTypes.cpp
-    PybindUtils.cpp
     Pass.cpp
 
     # Headers must be included explicitly so they are installed.
     Globals.h
     IRModule.h
     Pass.h
     PybindUtils.h
   PRIVATE_LINK_LIBS