src/test/ui/lint/lint-ctypes-fn.rs

   1 #![feature(rustc_private)]
   2
   3 #![allow(private_in_public)]
   4 #![deny(improper_ctypes_definitions)]
   5
   6 extern crate libc;
   7
   8 use std::default::Default;
   9 use std::marker::PhantomData;
  10
  11 trait Trait {}
  12
  13 trait Mirror { type It: ?Sized; }
  14
  15 impl<T: ?Sized> Mirror for T { type It = Self; }
  16
  17 #[repr(C)]
  18 pub struct StructWithProjection(*mut <StructWithProjection as Mirror>::It);
  19
  20 #[repr(C)]
  21 pub struct StructWithProjectionAndLifetime<'a>(
  22     &'a mut <StructWithProjectionAndLifetime<'a> as Mirror>::It
  23 );
  24
  25 pub type I32Pair = (i32, i32);
  26
  27 #[repr(C)]
  28 pub struct ZeroSize;
  29
  30 pub type RustFn = fn();
  31
  32 pub type RustBadRet = extern "C" fn() -> Box<u32>;
  33
  34 pub type CVoidRet = ();
  35
  36 pub struct Foo;
  37
  38 #[repr(transparent)]
  39 pub struct TransparentI128(i128);
  40
  41 #[repr(transparent)]
  42 pub struct TransparentStr(&'static str);
  43
  44 #[repr(transparent)]
  45 pub struct TransparentBadFn(RustBadRet);
  46
  47 #[repr(transparent)]
  48 pub struct TransparentInt(u32);
  49
  50 #[repr(transparent)]
  51 pub struct TransparentRef<'a>(&'a TransparentInt);
  52
  53 #[repr(transparent)]
  54 pub struct TransparentLifetime<'a>(*const u8, PhantomData<&'a ()>);
  55
  56 #[repr(transparent)]
  57 pub struct TransparentUnit<U>(f32, PhantomData<U>);
  58
  59 #[repr(transparent)]
  60 pub struct TransparentCustomZst(i32, ZeroSize);
  61
  62 #[repr(C)]
  63 pub struct ZeroSizeWithPhantomData(PhantomData<i32>);
  64
  65 pub extern "C" fn ptr_type1(size: *const Foo) { }
  66
  67 pub extern "C" fn ptr_type2(size: *const Foo) { }
  68
  69 pub extern "C" fn slice_type(p: &[u32]) { }
  70 //~^ ERROR: uses type `[u32]`
  71
  72 pub extern "C" fn str_type(p: &str) { }
  73 //~^ ERROR: uses type `str`
  74
  75 pub extern "C" fn box_type(p: Box<u32>) { }
  76
  77 pub extern "C" fn opt_box_type(p: Option<Box<u32>>) { }
  78
  79 pub extern "C" fn boxed_slice(p: Box<[u8]>) { }
  80 //~^ ERROR: uses type `Box<[u8]>`
  81
  82 pub extern "C" fn boxed_string(p: Box<str>) { }
  83 //~^ ERROR: uses type `Box<str>`
  84
  85 pub extern "C" fn boxed_trait(p: Box<dyn Trait>) { }
  86 //~^ ERROR: uses type `Box<dyn Trait>`
  87
  88 pub extern "C" fn char_type(p: char) { }
  89 //~^ ERROR uses type `char`
  90
  91 pub extern "C" fn i128_type(p: i128) { }
  92 //~^ ERROR uses type `i128`
  93
  94 pub extern "C" fn u128_type(p: u128) { }
  95 //~^ ERROR uses type `u128`
  96
  97 pub extern "C" fn tuple_type(p: (i32, i32)) { }
  98 //~^ ERROR uses type `(i32, i32)`
  99
 100 pub extern "C" fn tuple_type2(p: I32Pair) { }
 101 //~^ ERROR uses type `(i32, i32)`
 102
 103 pub extern "C" fn zero_size(p: ZeroSize) { }
 104 //~^ ERROR uses type `ZeroSize`
 105
 106 pub extern "C" fn zero_size_phantom(p: ZeroSizeWithPhantomData) { }
 107 //~^ ERROR uses type `ZeroSizeWithPhantomData`
 108
 109 pub extern "C" fn zero_size_phantom_toplevel() -> PhantomData<bool> {
 110 //~^ ERROR uses type `PhantomData<bool>`
 111     Default::default()
 112 }
 113
 114 pub extern "C" fn fn_type(p: RustFn) { }
 115 //~^ ERROR uses type `fn()`
 116
 117 pub extern "C" fn fn_type2(p: fn()) { }
 118 //~^ ERROR uses type `fn()`
 119
 120 pub extern "C" fn fn_contained(p: RustBadRet) { }
 121
 122 pub extern "C" fn transparent_i128(p: TransparentI128) { }
 123 //~^ ERROR: uses type `i128`
 124
 125 pub extern "C" fn transparent_str(p: TransparentStr) { }
 126 //~^ ERROR: uses type `str`
 127
 128 pub extern "C" fn transparent_fn(p: TransparentBadFn) { }
 129
 130 pub extern "C" fn good3(fptr: Option<extern "C" fn()>) { }
 131
 132 pub extern "C" fn good4(aptr: &[u8; 4 as usize]) { }
 133
 134 pub extern "C" fn good5(s: StructWithProjection) { }
 135
 136 pub extern "C" fn good6(s: StructWithProjectionAndLifetime) { }
 137
 138 pub extern "C" fn good7(fptr: extern "C" fn() -> ()) { }
 139
 140 pub extern "C" fn good8(fptr: extern "C" fn() -> !) { }
 141
 142 pub extern "C" fn good9() -> () { }
 143
 144 pub extern "C" fn good10() -> CVoidRet { }
 145
 146 pub extern "C" fn good11(size: isize) { }
 147
 148 pub extern "C" fn good12(size: usize) { }
 149
 150 pub extern "C" fn good13(n: TransparentInt) { }
 151
 152 pub extern "C" fn good14(p: TransparentRef) { }
 153
 154 pub extern "C" fn good15(p: TransparentLifetime) { }
 155
 156 pub extern "C" fn good16(p: TransparentUnit<ZeroSize>) { }
 157
 158 pub extern "C" fn good17(p: TransparentCustomZst) { }
 159
 160 #[allow(improper_ctypes_definitions)]
 161 pub extern "C" fn good18(_: &String) { }
 162
 163 #[cfg(not(target_arch = "wasm32"))]
 164 pub extern "C" fn good1(size: *const libc::c_int) { }
 165
 166 #[cfg(not(target_arch = "wasm32"))]
 167 pub extern "C" fn good2(size: *const libc::c_uint) { }
 168
 169 pub extern "C" fn unused_generic1<T>(size: *const Foo) { }
 170
 171 pub extern "C" fn unused_generic2<T>() -> PhantomData<bool> {
 172 //~^ ERROR uses type `PhantomData<bool>`
 173     Default::default()
 174 }
 175
 176 pub extern "C" fn used_generic1<T>(x: T) { }
 177
 178 pub extern "C" fn used_generic2<T>(x: T, size: *const Foo) { }
 179
 180 pub extern "C" fn used_generic3<T: Default>() -> T {
 181     Default::default()
 182 }
 183
 184 pub extern "C" fn used_generic4<T>(x: Vec<T>) { }
 185 //~^ ERROR: uses type `Vec<T>`
 186
 187 pub extern "C" fn used_generic5<T>() -> Vec<T> {
 188 //~^ ERROR: uses type `Vec<T>`
 189     Default::default()
 190 }
 191
 192 fn main() {}