Supporting Union in C and LLVM backend

[czgdp1807]

#1113

[certik]

This is just syntax (so the least important part of the PR), but isn't this more readable:

Suggested change

	class u_type(Union):
	_fields_ = ("integer32", ctype(i32)), ("real32", ctype(f32)), ("real64", ctype(f64)), ("integer64", ctype(i64))
	@ccall
	class u_type(Union):
	integer32: i32
	real32: f32
	real64: f64
	integer64: i64

The @ccall is telling LPyhon that this u_type Union has to be interoperable with C. Without the decorator it does not have to be.

Then Union I think doesn't care about the order of the elements (but if it does, we'll use the order as written, just like for a struct).

[certik]

I think this might be using some ctypes style. I would use our own simpler style, just like with the @ccall decorator, where we use our own natural style using Python annotations, but then underneath we implement it using ctypes.

[czgdp1807]

LPython can work with any syntax. We need it to work with CPython, so if ccall syntax works with CPython I will also prefer it.

[czgdp1807]

I updated the syntax and ltypes.py to make CPython work with this new syntax.

[certik]

I think the new syntax looks much better, thanks!

[certik]

Let's also test (probably in a new test file) a Union that is not c interoperable:

class D(Union):
    dx: i64
    dy: f64
    dz: f64

Btw, I think this union feature can also be used for common blocks and equivalence in LFortran, see lfortran/lfortran#718.

[certik]

Great job, I think this looks good. We might need to update / change the syntax if needed, but to the core functionality it seems it should work.

How do you create a Union that is not c interoperable? Or is this mean to be C interoperable?

It seems, we might need to use ctypes underneath to emulate unions even in Python, even if they are not c interoperable. If so, then I would change the syntax to the following:

# Regular pure Python Union (underneath the `@union` decorator might need to use ctypes to implement this)
@union
class D:
    dx: i64
    dy: f64
    dz: f64

# C interoperable union, can be passed to a function implemented in C
@ccall
@union
class D:
    dx: i64
    dy: f64
    dz: f64

[czgdp1807]

Makes sense. Will update tomorrow.

[czgdp1807]

Makes sense. Will update tomorrow.

@certik Done.

[certik]

Otherwise good.

[konradha]

Oh that's a great addition!