Find a better way of representing complex numbers types in Rust

[emilio]

I plan to land parsing and code generation support for complex types. My initial plan is landing it as a constant array of items, but that doesn't mean we can't do better.

We'd need to add a new TypeKind::Complex(ItemId), then use that to represent complex types. Then, at code generation, we can do something like what we do with unions, and conditionally prepend a prelude that might look like:

#[repr(C)]
#[derive(ABunchOfThings)]
struct __BindgenComplex<T> {
    real: T,
    imaginary: T,
};

With arithmetic operations on top of it.

[emilio]

The TypeKind::Complex differentiation will also be needed to correctly pass complex types by value to functions, since otherwise right now they'll get converted to pointers.

[jeanphilippeD]

Hello,
Should we rely on num-complex if we want the arithmetic?
Then the prelude would be:

extern crate num_complex;
use num_complex::*;

Otherwise, we could also provide a compatible, dumb generic if we want to limit dependencies (the arithmetic seems quite involved). then the prelude would be:

#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
pub struct __BindgenComplex<T> {
    pub re: T,
    pub im: T
}

Would that make sense?
Which option would be best?

I'd be interested in trying to add one option.
Thanks,
JP

[emilio]

I think avoid bindgen dependencies is nice, so I think I'd prefer the second option. Also, we can't rely on num_complex having the expected representation (the type needs to be repr(C)), and anybody that needs the arithmetic can do a straight-forward conversion from our representation to num_complex's.

So yeah, definitely the second option is preferred. If you need any help, please shout out, I'll be happy to help. Should be straight-forward (sort of what we do for union fields).