[mlir][python] Add python binding for AffineMapAttribute.

mlir/lib/Bindings/Python/IRModules.cpp

static void bind(py::module &m) {
     cls.def(py::init<PyAttribute &>(), py::keep_alive<0, 1>());
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
+class PyAffineMapAttribute : public PyConcreteAttribute<PyAffineMapAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAAffineMap;
+  static constexpr const char *pyClassName = "AffineMapAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](PyAffineMap &affineMap) {
+          MlirAttribute attr = mlirAffineMapAttrGet(affineMap.get());
+          return PyAffineMapAttribute(affineMap.getContext(), attr);
+        },
+        py::arg("affine_map"), "Gets an attribute wrapping an AffineMap.");
+  }
+};
+
 class PyArrayAttribute : public PyConcreteAttribute<PyArrayAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAArray;
   static constexpr const char *pyClassName = "ArrayAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   class PyArrayAttributeIterator {
   public:
py::class_<PyNamedAttribute>(m, "NamedAttribute")
             auto contextRef = PyMlirContext::forContext(
                 mlirAttributeGetContext(self.namedAttr.attribute));
             return PyAttribute(std::move(contextRef), self.namedAttr.attribute);
           },
           py::keep_alive<0, 1>(),
           "The underlying generic attribute of the NamedAttribute binding");
 
   // Builtin attribute bindings.
-  PyFloatAttribute::bind(m);
+  PyAffineMapAttribute::bind(m);
   PyArrayAttribute::bind(m);
   PyArrayAttribute::PyArrayAttributeIterator::bind(m);
-  PyIntegerAttribute::bind(m);
   PyBoolAttribute::bind(m);
-  PyFlatSymbolRefAttribute::bind(m);
-  PyStringAttribute::bind(m);
   PyDenseElementsAttribute::bind(m);
-  PyDenseIntElementsAttribute::bind(m);
   PyDenseFPElementsAttribute::bind(m);
+  PyDenseIntElementsAttribute::bind(m);
   PyDictAttribute::bind(m);
+  PyFlatSymbolRefAttribute::bind(m);
+  PyFloatAttribute::bind(m);
+  PyIntegerAttribute::bind(m);
+  PyStringAttribute::bind(m);
   PyTypeAttribute::bind(m);
   PyUnitAttribute::bind(m);
 
   //----------------------------------------------------------------------------
   // Mapping of PyType.
   //----------------------------------------------------------------------------
   py::class_<PyType>(m, "Type")
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR, &PyType::getCapsule)

mlir/test/Bindings/Python/ir_attributes.py

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: testAffineMapAttr
+def testAffineMapAttr():
+  with Context() as ctx:
+    d0 = AffineDimExpr.get(0)
+    d1 = AffineDimExpr.get(1)
+    c2 = AffineConstantExpr.get(2)
+    map0 = AffineMap.get(2, 3, [])
+
+    # CHECK: affine_map<(d0, d1)[s0, s1, s2] -> ()>
+    attr_built = AffineMapAttr.get(map0)
+    print(str(attr_built))
+
+    attr_parsed = Attribute.parse(str(attr_built))
+    assert attr_built == attr_parsed
+
+run(testAffineMapAttr)
+
+
 # CHECK-LABEL: TEST: testFloatAttr
 def testFloatAttr():
   with Context(), Location.unknown():
     fattr = FloatAttr(Attribute.parse("42.0 : f32"))
     # CHECK: fattr value: 42.0
     print("fattr value:", fattr.value)
 
     # Test factory methods.