Different types on Windows?

[NoraCodes]

Input C/C++ Header

// We have a lot of enums defined using this macro
#define __UI_ENUM(s) typedef unsigned int s; enum

// Like this
_UI_ENUM(uiAlign) {
    uiAlignFill,
    uiAlignStart,
    uiAlignFill,
    uiAlignEnd,
}

Bindgen Invocation

// Generate libui bindings on the fly
    let bindings = BindgenBuilder::default()
        .header("wrapper.h")
        .opaque_type("max_align_t") // For some reason this ends up too large
        .generate()
        .expect("Unable to generate bindings");

The Issue

I use these enums in Rust code, for instance, here:

// Where GridAlignment is an enum and ui_sys is the bindings
use ui_sys::{self, uiAlign};
impl GridAlignment {
    fn into_ui_align(self) -> uiAlign {
        use self::GridAlignment::*;
        match self {
            Fill => ui_sys::uiAlignFill,
            Start => ui_sys::uiAlignStart,
            Center => ui_sys::uiAlignCenter,
            End => ui_sys::uiAlignEnd
        }
    }
}

On Linux, this code works. On Windows, it does not:

error[E0308]: match arms have incompatible types
   --> iui\src\controls\layout.rs:283:9
    |
283 | /         match self {
284 | |             Fill => ui_sys::uiAlignFill,
    | |                     ------------------- match arm with an incompatible type
285 | |             Start => ui_sys::uiAlignStart,
286 | |             Center => ui_sys::uiAlignCenter,
287 | |             End => ui_sys::uiAlignEnd 
288 | |         }
    | |_________^ expected u32, found i32

Check out more details, if needed, at LeoTindall/libui-rs#29

[emilio]

This is invalid, I think. MSVC generates a different underlying type for enums by default, see:

https://godbolt.org/g/i9EMTL

That program, which for reference is:

#include <type_traits>

#define __UI_ENUM(s) typedef unsigned int s; enum
extern "C" {
__UI_ENUM(uiAlign) {
    uiAlignFill,
    uiAlignStart,
    uiAlignEnd,
};
}

int main() {
  static_assert(
    std::is_same<std::underlying_type<decltype(uiAlignFill)>::type, unsigned>::value,
    "Huh");
}

Only fails to compile on MSVC.

So bindgen is right in this case, even if it ends up not quite mattering given the values never go out of range (I hope :)).

If it was C++ you could use enum class or something to force the type layout you want... You could also explicitly cast in the rust side where it matters, or use rustified_enum("ui.*"), for example, if you're generating bindings on the fly and you know that you never generate values that are not specified in a given enum variant on the rust side.

Let me know if I can help more to get the bindings working and in a sane state, binding to libui is really cool!

[NoraCodes]

Thanks for reproducing that! MSVC is... wrong in this case, I think? We do explicitly ask for an unsigned enum.

In any case, using Rust-ified enums should be fine here. I'll let you know if I have any more issues.

[davidkna]

I don't think so because I think the enum is anonymous and uiAlign is only an alias for unsigned here and enums are not guranteed to be unsigned AFAIK.

[NoraCodes]

Oh, I see! Thanks, I misunderstood what that declaration was doing.