[mlir][python] Mark operator== overloads as const

[rkayaith]

Summary

This resolves some warnings when building with C++20, e.g.:

llvm-project/mlir/lib/Bindings/Python/IRAffine.cpp:545:60: warning: ISO C++20 considers use of overloaded operator '==' (with operand types 'mlir::python::PyAffineExpr' and 'mlir::python::PyAffineExpr') to be ambiguous despite there being a unique best viable function [-Wambiguous-reversed-operator]
                        PyAffineExpr &other) { return self == other; })
                                                      ~~~~ ^  ~~~~~
llvm-project/mlir/lib/Bindings/Python/IRAffine.cpp:350:20: note: ambiguity is between a regular call to this operator and a call with the argument order reversed
bool PyAffineExpr::operator==(const PyAffineExpr &other) {
                   ^

mlir/lib/Bindings/Python/IRAffine.cpp

public:
 
   static void bindDerived(ClassTy &c) {
     c.def_static("get", &PyAffineCeilDivExpr::get);
   }
 };
 
 } // namespace
 
-bool PyAffineExpr::operator==(const PyAffineExpr &other) {
+bool PyAffineExpr::operator==(const PyAffineExpr &other) const {
   return mlirAffineExprEqual(affineExpr, other.affineExpr);
 }
 
 py::object PyAffineExpr::getCapsule() {
   return py::reinterpret_steal<py::object>(
       mlirPythonAffineExprToCapsule(*this));
 }
 
PyAffineMapExprList slice(intptr_t startIndex, intptr_t length,
                             intptr_t step) {
     return PyAffineMapExprList(affineMap, startIndex, length, step);
   }
 
   PyAffineMap affineMap;
 };
 } // namespace
 
-bool PyAffineMap::operator==(const PyAffineMap &other) {
+bool PyAffineMap::operator==(const PyAffineMap &other) const {
   return mlirAffineMapEqual(affineMap, other.affineMap);
 }
 
 py::object PyAffineMap::getCapsule() {
   return py::reinterpret_steal<py::object>(mlirPythonAffineMapToCapsule(*this));
 }
 
 PyAffineMap PyAffineMap::createFromCapsule(py::object capsule) {
PyIntegerSetConstraintList slice(intptr_t startIndex, intptr_t length,
                                    intptr_t step) {
     return PyIntegerSetConstraintList(set, startIndex, length, step);
   }
 
   PyIntegerSet set;
 };
 } // namespace
 
-bool PyIntegerSet::operator==(const PyIntegerSet &other) {
+bool PyIntegerSet::operator==(const PyIntegerSet &other) const {
   return mlirIntegerSetEqual(integerSet, other.integerSet);
 }
 
 py::object PyIntegerSet::getCapsule() {
   return py::reinterpret_steal<py::object>(
       mlirPythonIntegerSetToCapsule(*this));
 }
 

mlir/lib/Bindings/Python/IRCore.cpp

void PyInsertionPoint::contextExit(const pybind11::object &excType,
                                    const pybind11::object &excTb) {
   PyThreadContextEntry::popInsertionPoint(*this);
 }
 
 //------------------------------------------------------------------------------
 // PyAttribute.
 //------------------------------------------------------------------------------
 
-bool PyAttribute::operator==(const PyAttribute &other) {
+bool PyAttribute::operator==(const PyAttribute &other) const {
   return mlirAttributeEqual(attr, other.attr);
 }
 
 py::object PyAttribute::getCapsule() {
   return py::reinterpret_steal<py::object>(mlirPythonAttributeToCapsule(*this));
 }
 
 PyAttribute PyAttribute::createFromCapsule(py::object capsule) {
namedAttr = mlirNamedAttributeGet(
                         toMlirStringRef(*this->ownedName)),
       attr);
 }
 
 //------------------------------------------------------------------------------
 // PyType.
 //------------------------------------------------------------------------------
 
-bool PyType::operator==(const PyType &other) {
+bool PyType::operator==(const PyType &other) const {
   return mlirTypeEqual(type, other.type);
 }
 
 py::object PyType::getCapsule() {
   return py::reinterpret_steal<py::object>(mlirPythonTypeToCapsule(*this));
 }
 
 PyType PyType::createFromCapsule(py::object capsule) {

mlir/lib/Bindings/Python/IRModule.h

private:
   PyBlock block;
 };
 /// Wrapper around the generic MlirType.
 /// The lifetime of a type is bound by the PyContext that created it.
 class PyType : public BaseContextObject {
 public:
   PyType(PyMlirContextRef contextRef, MlirType type)
       : BaseContextObject(std::move(contextRef)), type(type) {}
-  bool operator==(const PyType &other);
+  bool operator==(const PyType &other) const;
   operator MlirType() const { return type; }
   MlirType get() const { return type; }
 
   /// Gets a capsule wrapping the void* within the MlirType.
   pybind11::object getCapsule();
 
   /// Creates a PyType from the MlirType wrapped by a capsule.
   /// Note that PyType instances are uniqued, so the returned object

 };
 
 /// Wrapper around the generic MlirAttribute.
 /// The lifetime of a type is bound by the PyContext that created it.
 class PyAttribute : public BaseContextObject {
 public:
   PyAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
       : BaseContextObject(std::move(contextRef)), attr(attr) {}
-  bool operator==(const PyAttribute &other);
+  bool operator==(const PyAttribute &other) const;
   operator MlirAttribute() const { return attr; }
   MlirAttribute get() const { return attr; }
 
   /// Gets a capsule wrapping the void* within the MlirAttribute.
   pybind11::object getCapsule();
 
   /// Creates a PyAttribute from the MlirAttribute wrapped by a capsule.
   /// Note that PyAttribute instances are uniqued, so the returned object
private:
   MlirValue value;
 };
 
 /// Wrapper around MlirAffineExpr. Affine expressions are owned by the context.
 class PyAffineExpr : public BaseContextObject {
 public:
   PyAffineExpr(PyMlirContextRef contextRef, MlirAffineExpr affineExpr)
       : BaseContextObject(std::move(contextRef)), affineExpr(affineExpr) {}
-  bool operator==(const PyAffineExpr &other);
+  bool operator==(const PyAffineExpr &other) const;
   operator MlirAffineExpr() const { return affineExpr; }
   MlirAffineExpr get() const { return affineExpr; }
 
   /// Gets a capsule wrapping the void* within the MlirAffineExpr.
   pybind11::object getCapsule();
 
   /// Creates a PyAffineExpr from the MlirAffineExpr wrapped by a capsule.
   /// Note that PyAffineExpr instances are uniqued, so the returned object

 private:
   MlirAffineExpr affineExpr;
 };
 
 class PyAffineMap : public BaseContextObject {
 public:
   PyAffineMap(PyMlirContextRef contextRef, MlirAffineMap affineMap)
       : BaseContextObject(std::move(contextRef)), affineMap(affineMap) {}
-  bool operator==(const PyAffineMap &other);
+  bool operator==(const PyAffineMap &other) const;
   operator MlirAffineMap() const { return affineMap; }
   MlirAffineMap get() const { return affineMap; }
 
   /// Gets a capsule wrapping the void* within the MlirAffineMap.
   pybind11::object getCapsule();
 
   /// Creates a PyAffineMap from the MlirAffineMap wrapped by a capsule.
   /// Note that PyAffineMap instances are uniqued, so the returned object
   /// may be a pre-existing object. Ownership of the underlying MlirAffineMap
   /// is taken by calling this function.
   static PyAffineMap createFromCapsule(pybind11::object capsule);
 
 private:
   MlirAffineMap affineMap;
 };
 
 class PyIntegerSet : public BaseContextObject {
 public:
   PyIntegerSet(PyMlirContextRef contextRef, MlirIntegerSet integerSet)
       : BaseContextObject(std::move(contextRef)), integerSet(integerSet) {}
-  bool operator==(const PyIntegerSet &other);
+  bool operator==(const PyIntegerSet &other) const;
   operator MlirIntegerSet() const { return integerSet; }
   MlirIntegerSet get() const { return integerSet; }
 
   /// Gets a capsule wrapping the void* within the MlirIntegerSet.
   pybind11::object getCapsule();
 
   /// Creates a PyIntegerSet from the MlirAffineMap wrapped by a capsule.
   /// Note that PyIntegerSet instances may be uniqued, so the returned object