improper_ctypes complains about types that contain PhantomData

[Ms2ger]

#[repr(C)]
pub struct Foo(::std::marker::PhantomData<i32>);
extern {
    pub fn f(foo: *mut Foo);
}
fn main() {}

warning: found non-foreign-function-safe member in struct marked #[repr(C)]: found struct without foreign-function-safe representation annotation in foreign module, consider adding a #[repr(C)] attribute to the type, #[warn(improper_ctypes)] on by default
 --> <anon>:5:19
5 |>     pub fn f(foo: *mut Foo);
  |>                   ^^^^^^^^

This comes up in bindings generated from C code that contains unions (the __BindgenUnionField type).

[TimNN]

The problem, as far as I know, is that *mut Foo really is not ffi safe.

This is because Zero Sized Types (which Foo is) as well as pointers to Zero Sized Types are not ffi safe (again, as far as I know).

[oli-obk]

it also happens (although with a slightly different message) when the type is not ZST: https://is.gd/8529c8

warning: found non-foreign-function-safe member in struct marked #[repr(C)]: found struct without foreign-function-safe representation annotation in foreign module, consider adding a #[repr(C)] attribute to the type, #[warn(improper_ctypes)] on by default
 --> <anon>:9:19
9 |>     pub fn f(foo: *mut Foo);
  |> 

[emilio]

Unfortunately, we need to use phantom data to use bindgen with C++, because a struct like:

template<typename T>
struct Foo {
    int bar;
};

The only way we can represent that in rust is

struct Foo<T> {
   bar: c_int,
   _phantom: PhantomData<T>,
}

[d3zd3z]

I've run into this issue with something similar

use std::marker::PhantomData;

fn main() {
    let buffer = vec![0u8; 16];
    let data = Data {
        ptr: &buffer[0],
        phantom: PhantomData,
    };
    unsafe { bogus(&data) };
}

#[repr(C)]
struct Data<'a> {
    ptr: *const u8,
    phantom: PhantomData<&'a [u8]>,
}

extern "C" {
    fn bogus(data: *const Data);
}

which generates the same kind of warning:

warning: found non-foreign-function-safe member in struct marked #[repr(C)]: found struct without foreign-function-safe representation annotation in foreign module, consider adding a #[repr(C)] attribute to the type, #[warn(improper_ctypes)] on by default
  --> src/main.rs:19:20
   |
19 |     fn bogus(data: *const Data);
   |                    ^^^^^^^^^^^

My real use-case has other fields in the struct, which are needed to match the C API.

[rillian]

I did a little poking around to understand how unsafe this is. In https://play.rust-lang.org/?gist=24634425b2bd8707c73f09e418900ec5 you can see that the PhantomData really is zero-size; it has the same address as the subsequent struct field.

However, it is reported in debuginfo. So while passing its address across the ffi boundary is I think covered by the existing safety rules, a debugger could be confused by the duplicate labels on the struct.