[mlir][python] Add Operation.verify().

mlir/lib/Bindings/Python/IRModules.cpp

py::class_<PyOperationBase>(m, "_OperationBase")
            py::arg("use_local_scope") = false, kOperationPrintDocstring)
       .def("get_asm", &PyOperationBase::getAsm,
            // Careful: Lots of arguments must match up with get_asm method.
            py::arg("binary") = false,
            py::arg("large_elements_limit") = py::none(),
            py::arg("enable_debug_info") = false,
            py::arg("pretty_debug_info") = false,
            py::arg("print_generic_op_form") = false,
-           py::arg("use_local_scope") = false, kOperationGetAsmDocstring);
+           py::arg("use_local_scope") = false, kOperationGetAsmDocstring)
+      .def(
+          "verify",
+          [](PyOperationBase &self) {
+            return mlirOperationVerify(self.getOperation());
+          },
+          "Verify the operation and return true if it passes, false if it "
+          "fails.");
 
   py::class_<PyOperation, PyOperationBase>(m, "Operation")
       .def_static("create", &PyOperation::create, py::arg("name"),
                   py::arg("operands") = py::none(),
                   py::arg("results") = py::none(),
                   py::arg("attributes") = py::none(),
                   py::arg("successors") = py::none(), py::arg("regions") = 0,
                   py::arg("loc") = py::none(), py::arg("ip") = py::none(),

mlir/test/Bindings/Python/ir_operation.py

def testTraverseOpRegionBlockIterators():
   op = module.operation
   assert op.context is ctx
   # Get the block using iterators off of the named collections.
   regions = list(op.regions)
   blocks = list(regions[0].blocks)
   # CHECK: MODULE REGIONS=1 BLOCKS=1
   print(f"MODULE REGIONS={len(regions)} BLOCKS={len(blocks)}")
 
+  # Should verify.
+  # CHECK: .verify = True
+  print(f".verify = {module.operation.verify()}")
+
   # Get the regions and blocks from the default collections.
   default_regions = list(op)
   default_blocks = list(default_regions[0])
   # They should compare equal regardless of how obtained.
   assert default_regions == regions
   assert default_blocks == blocks
 
   # Should be able to get the operations from either the named collection

 # CHECK-LABEL: TEST: testPrintInvalidOperation
 def testPrintInvalidOperation():
   ctx = Context()
   with Location.unknown(ctx):
     module = Operation.create("module", regions=1)
     # This block does not have a terminator, it may crash the custom printer.
     # Verify that we fallback to the generic printer for safety.
     block = module.regions[0].blocks.append()
-    print(module)
     # CHECK: // Verification failed, printing generic form
     # CHECK: "module"() ( {
     # CHECK: }) : () -> ()
+    print(module)
+    # CHECK: .verify = False
+    print(f".verify = {module.operation.verify()}")
 run(testPrintInvalidOperation)
 
 
 # CHECK-LABEL: TEST: testCreateWithInvalidAttributes
 def testCreateWithInvalidAttributes():
   ctx = Context()
   with Location.unknown(ctx):
     try: