[mlir][python] Add tests for implicit pybind casts.

[ingomueller-net]

Summary

https://reviews.llvm.org/D158974 Implement __<type>__ functions for
bool, float, int, and str for automatic casts in functions bound
by pybind11. This patch tests their behavior more thoroughly. In
particular, this clarifies an open question from the dicussion of above
patch: values for string parameters, unlike for the other types, are
*not* cast implicitly with str(.)

[rkayaith]

Is there still a reason to implement __str__ for StringAttr then? It seems to just add inconsistency, as the implementation on every other attribute gives the asm string.

[ingomueller-net]

Do these tests provide value beyond finding out how __str__ and pybind11 interact? If yes, I guess I'll rebase this patch on top of https://reviews.llvm.org/D159255 and land (after approval)...

[rkayaith]

I think only the positive tests for Attribute conversions are really relevant. And since that's covered by tests in the original change, it seems fine to drop this patch.

[ingomueller-net]

The only thing that isn't tested that explicitly in the attributes tests is that the automatic conversion done by pybind works as expected. But in a way that's a pybind feature... Abandoning.

mlir/python/mlir/dialects/python_test.py

 #  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
 
 from ._python_test_ops_gen import *
-from .._mlir_libs._mlirPythonTest import TestAttr, TestType, TestTensorValue, TestIntegerRankedTensorType
+from .._mlir_libs._mlirPythonTest import *
 
 
 def register_python_test_dialect(context, load=True):
     from .._mlir_libs import _mlirPythonTest
 
     _mlirPythonTest.register_python_test_dialect(context, load)

mlir/test/python/dialects/python_test.py

 # CHECK-LABEL: TEST: testOptionalOperandOp
 @run
 def testOptionalOperandOp():
     with Context() as ctx, Location.unknown():
         test.register_python_test_dialect(ctx)
 
         module = Module.create()
         with InsertionPoint(module.body):
-
             op1 = test.OptionalOperandOp()
             # CHECK: op1.input is None: True
             print(f"op1.input is None: {op1.input is None}")
 
             op2 = test.OptionalOperandOp(input=op1)
             # CHECK: op2.input is None: False
             print(f"op2.input is None: {op2.input is None}")
 
with Context() as ctx, Location.unknown(ctx):
 
             one_operand = test.InferResultsVariadicInputsOp(single=zero, doubled=None)
             # CHECK: i32
             print(one_operand.result.type)
 
             two_operands = test.InferResultsVariadicInputsOp(single=zero, doubled=zero)
             # CHECK: f32
             print(two_operands.result.type)
+
+
+@run
+def testTypeCasting():
+    def try_print(x):
+        try:
+            test.print(x)
+        except Exception as ex:
+            print("error:", ex)
+
+    # CHECK: bool: True
+    try_print(True)
+
+    # CHECK: int: 42
+    try_print(42)
+
+    # CHECK: float: 4.25
+    try_print(4.25)
+
+    # CHECK: str: hello
+    try_print("hello")
+
+    # CHECK: error: print(): incompatible function arguments.
+    try_print(object())
+
+    # CHECK: str: <object object at 0x
+    try_print(str(object()))
+
+    class MyBool:
+        def __bool__(self):
+            return False
+
+    # CHECK: bool: False
+    try_print(MyBool())
+
+    class MyInt:
+        def __int__(self):
+            return 1337
+
+    # CHECK: int: 1337
+    try_print(MyInt())
+
+    class MyFloat:
+        def __float__(self):
+            return 1.0
+
+    # CHECK: float: 1.0
+    try_print(MyFloat())
+
+    class MyStr:
+        def __str__(self):
+            return "world"
+
+    # CHECK: error: print(): incompatible function arguments.
+    try_print(MyStr())
+
+    # CHECK: str: world
+    try_print(str(MyStr()))
+
+    with Context():
+        # CHECK: bool: True
+        try_print(Attribute.parse("true"))
+
+        # CHECK: int: 420
+        try_print(Attribute.parse("420 : i32"))
+
+        # CHECK: float: 12.5
+        try_print(Attribute.parse("12.5 : f32"))
+
+        # CHECK: error: print(): incompatible function arguments.
+        try_print(Attribute.parse('"hello world!"'))
+
+        # CHECK: str: hello world!
+        try_print(str(Attribute.parse('"hello world!"')))

mlir/test/python/lib/PythonTestModule.cpp

m.def(
             mlirGetDialectHandle__python_test__();
         mlirDialectHandleRegisterDialect(pythonTestDialect, context);
         if (load) {
           mlirDialectHandleLoadDialect(pythonTestDialect, context);
         }
       },
       py::arg("context"), py::arg("load") = true);
 
+  m.def(
+      "print", [](bool x) { py::print("bool:", x); }, py::arg("x"));
+  m.def(
+      "print", [](int x) { py::print("int:", x); }, py::arg("x"));
+  m.def(
+      "print", [](double x) { py::print("float:", x); }, py::arg("x"));
+  m.def(
+      "print", [](std::string x) { py::print("str:", x); }, py::arg("x"));
+
   mlir_attribute_subclass(m, "TestAttr",
                           mlirAttributeIsAPythonTestTestAttribute)
       .def_classmethod(
           "get",
           [](py::object cls, MlirContext ctx) {
             return cls(mlirPythonTestTestAttributeGet(ctx));
           },
           py::arg("cls"), py::arg("context") = py::none());