Even more failing layout tests with SpiderMonkey bindings

[fitzgen]

Input C/C++ Header

template <int b> struct c { char d[b]; };
template <int e> struct f { static const long g = e; };
template <int e> struct h { static const long g = e; };
class i {
  int j;
};
template <typename k, class l> class m : l {
  struct n {
    static const long g = sizeof(k);
  };
  static const long a = f<n::g>::g;
  static const long b = h<a * n::g>::g;
  k o;
  long p;
  long q;
  long r;
  c<b> s;
  bool t;
};
template <typename k> class G {
  using af = void *;
  af ag;
  k ah;
};
template <typename k> using aj = G<k>;
template <typename k> class u {
  u *a;
  u *am;
  aj<k> an;
};
struct I {
  long ap;
};
namespace JS {
class v {
  m<I, i> ar;
};
class AutoIdVector : u<v> {};
}

Bindgen Invokation

$ bindgen input.hpp -- -std=c++14

Actual Results

Emits these bindings:

/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Debug, Copy)]
pub struct i {
    pub j: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_i() {
    assert_eq!(::std::mem::size_of::<i>() , 4usize , concat ! (
               "Size of: " , stringify ! ( i ) ));
    assert_eq! (::std::mem::align_of::<i>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( i ) ));
    assert_eq! (unsafe { & ( * ( 0 as * const i ) ) . j as * const _ as usize
                } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( i ) , "::" , stringify
                ! ( j ) ));
}
impl Clone for i {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
pub struct m<k, l> {
    pub _base: l,
    pub o: k,
    pub p: ::std::os::raw::c_long,
    pub q: ::std::os::raw::c_long,
    pub r: ::std::os::raw::c_long,
    pub s: (),
    pub t: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct m_n {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct G<k> {
    pub ag: G_af,
    pub ah: k,
}
pub type G_af = *mut ::std::os::raw::c_void;
pub type aj<k> = G<k>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct u<k> {
    pub a: *mut u<k>,
    pub am: *mut u<k>,
    pub an: aj<k>,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct I {
    pub ap: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_I() {
    assert_eq!(::std::mem::size_of::<I>() , 8usize , concat ! (
               "Size of: " , stringify ! ( I ) ));
    assert_eq! (::std::mem::align_of::<I>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( I ) ));
    assert_eq! (unsafe { & ( * ( 0 as * const I ) ) . ap as * const _ as usize
                } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( I ) , "::" , stringify
                ! ( ap ) ));
}
impl Clone for I {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
pub struct JS_v {
    pub ar: m<I, i>,
}
#[test]
fn bindgen_test_layout_JS_v() {
    assert_eq!(::std::mem::size_of::<JS_v>() , 112usize , concat ! (
               "Size of: " , stringify ! ( JS_v ) ));
    assert_eq! (::std::mem::align_of::<JS_v>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( JS_v ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const JS_v ) ) . ar as * const _ as usize } ,
                0usize , concat ! (
                "Alignment of field: " , stringify ! ( JS_v ) , "::" ,
                stringify ! ( ar ) ));
}
#[repr(C)]
pub struct JS_AutoIdVector {
    pub _base: u<JS_v>,
}
#[test]
fn bindgen_test_layout_JS_AutoIdVector() {
    assert_eq!(::std::mem::size_of::<JS_AutoIdVector>() , 136usize , concat !
               ( "Size of: " , stringify ! ( JS_AutoIdVector ) ));
    assert_eq! (::std::mem::align_of::<JS_AutoIdVector>() , 8usize , concat !
                ( "Alignment of " , stringify ! ( JS_AutoIdVector ) ));
}
#[test]
fn __bindgen_test_layout_u_instantiation_81() {
    assert_eq!(::std::mem::size_of::<u<JS_v>>() , 136usize , concat ! (
               "Size of template specialization: " , stringify ! ( u<JS_v> )
               ));
    assert_eq!(::std::mem::align_of::<u<JS_v>>() , 8usize , concat ! (
               "Alignment of template specialization: " , stringify ! (
               u<JS_v> ) ));
}

Compiling with --test and running the layout tests results in this failure:

running 5 tests
test __bindgen_test_layout_u_instantiation_81 ... FAILED
test bindgen_test_layout_I ... ok
test bindgen_test_layout_JS_AutoIdVector ... FAILED
test bindgen_test_layout_JS_v ... FAILED
test bindgen_test_layout_i ... ok

failures:

---- __bindgen_test_layout_u_instantiation_81 stdout ----
	thread '__bindgen_test_layout_u_instantiation_81' panicked at 'assertion failed: `(left == right)` (left: `72`, right: `136`): Size of template specialization: u < JS_v >', js.rs:100
note: Run with `RUST_BACKTRACE=1` for a backtrace.

---- bindgen_test_layout_JS_AutoIdVector stdout ----
	thread 'bindgen_test_layout_JS_AutoIdVector' panicked at 'assertion failed: `(left == right)` (left: `72`, right: `136`): Size of: JS_AutoIdVector', js.rs:93

---- bindgen_test_layout_JS_v stdout ----
	thread 'bindgen_test_layout_JS_v' panicked at 'assertion failed: `(left == right)` (left: `48`, right: `112`): Size of: JS_v', js.rs:77


failures:
    __bindgen_test_layout_u_instantiation_81
    bindgen_test_layout_JS_AutoIdVector
    bindgen_test_layout_JS_v

test result: FAILED. 2 passed; 3 failed; 0 ignored; 0 measured

Expected Results

We shouldn't fail layout tests. Even in the face of constructs for which we cannot meaningfully make Rust equivalents, we should generate opaque blobs of the correct size.

[fitzgen]

More reduced test case:

template <int>
struct UnusedIntTemplateParam {};

template <class>
class Outer {
    static const long SIZE = 1;
    UnusedIntTemplateParam<SIZE> i;
};

class AutoIdVector {
  Outer<int> ar;
};

Interesting that removing the unused template parameter from Outer makes the test pass...