How to do data conversion between Mojo data types and MLIR data types?

[zhwa]

In Mojo's tutorial, it is shown that Mojo data types can be easily constructed with MLIR data types:

let a : __mlir_type.i1 = __mlir_op.`index.bool.constant`[value : __mlir_attr.`false`]()
let b = Bool(a)

However, this conversion doesn't work in another direction:

let x : Bool = True
let y : __mlir_type.i1 = x  # errors

Similar examples can also be found in the doc, like Float64 and scalar<f64>. I wonder can the conversion be done with existing APIs like __mlir_op? Or, new APIs will be needed to support this scenario?

[lattner]

You can't add methods to MLIR types, and Python doesn't have a way of doing conversions like this. C++ has a way to do this with the "operator T()" sorts of methods, which we could add, but we haven't explored that part of the design space yet.

For now, the best way to go is to add a "to_i1()" sort of method to a type if you can, or define a to_i1(x) global function

[zhwa]

Thanks Chris!

From the point of view of a beginner, I think APIs to manipulate the MLIR types would be helpful in the future. For the case if i1, they might not be so necessary as you pointed out that the conversion can be easily done with something like

var y : __mlir_type.i1
if x:
    y = __mlir_op.`index.bool.constant`[value : __mlir_attr.`true`]()
else:
    y = __mlir_op.`index.bool.constant`[value : __mlir_attr.`false`]()

However, for more complicated types like scalar, f64, pointer, etc; there might not be a simple way to do the conversion. Surely not many people would need to work with such low level data types, but if someone needs to implement a specific data type (like a unique 8 bits floating point number to be used for quantization, for example), APIs to manipulate MLIR types would be helpful.

[lattner]

I'm not sure what you're getting at here @zhwa - Mojo doesn't know anything about about the semantics of mlir types or mlir operations when you're working at this level - this is like working with inline assembly in C, which is mostly opaque to the C compiler.

If you're looking for a way to convert values of things like i64 or f64 or pointers, you need to use mlir operations that preform those conversions - e.g. is the i64 treated as signed or unsigned? You can also use the builtin unrealized conversion cast if that is the right thing too of course.

Also, this level of abstraction is really not intended to be used by beginners :), this is really only intended for very specific uses by compiler hackers, who typically are co-designing their dialects with the corresponding Mojo library.