8 use std
::mem
::transmute
as my_transmute
;
9 use std
::vec
::Vec
as MyVec
;
11 fn my_int() -> Usize
{
15 fn my_vec() -> MyVec
<i32> {
19 #[allow(needless_lifetimes, transmute_ptr_to_ptr)]
20 #[warn(useless_transmute)]
21 unsafe fn _generic
<'a
, T
, U
: 'a
>(t
: &'a T
) {
22 let _
: &'a T
= core
::intrinsics
::transmute(t
);
24 let _
: &'a U
= core
::intrinsics
::transmute(t
);
26 let _
: *const T
= core
::intrinsics
::transmute(t
);
28 let _
: *mut T
= core
::intrinsics
::transmute(t
);
30 let _
: *const U
= core
::intrinsics
::transmute(t
);
33 #[warn(transmute_ptr_to_ref)]
34 unsafe fn _ptr_to_ref
<T
, U
>(p
: *const T
, m
: *mut T
, o
: *const U
, om
: *mut U
) {
35 let _
: &T
= std
::mem
::transmute(p
);
38 let _
: &mut T
= std
::mem
::transmute(m
);
39 let _
: &mut T
= &mut *m
;
41 let _
: &T
= std
::mem
::transmute(m
);
44 let _
: &mut T
= std
::mem
::transmute(p
as *mut T
);
45 let _
= &mut *(p
as *mut T
);
47 let _
: &T
= std
::mem
::transmute(o
);
48 let _
: &T
= &*(o
as *const T
);
50 let _
: &mut T
= std
::mem
::transmute(om
);
51 let _
: &mut T
= &mut *(om
as *mut T
);
53 let _
: &T
= std
::mem
::transmute(om
);
54 let _
: &T
= &*(om
as *const T
);
57 #[warn(transmute_ptr_to_ref)]
59 struct Foo
<'a
, T
: 'a
> {
63 let raw
= 42 as *const i32;
64 let _
: &Foo
<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) }
;
66 let _
: &Foo
<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) }
;
68 type Bar
<'a
> = &'a
u8;
69 let raw
= 42 as *const i32;
70 unsafe { std::mem::transmute::<_, Bar>(raw) }
;
73 #[warn(useless_transmute)]
76 let _
: Vec
<i32> = core
::intrinsics
::transmute(my_vec());
78 let _
: Vec
<i32> = core
::mem
::transmute(my_vec());
80 let _
: Vec
<i32> = std
::intrinsics
::transmute(my_vec());
82 let _
: Vec
<i32> = std
::mem
::transmute(my_vec());
84 let _
: Vec
<i32> = my_transmute(my_vec());
86 let _
: Vec
<u32> = core
::intrinsics
::transmute(my_vec());
87 let _
: Vec
<u32> = core
::mem
::transmute(my_vec());
88 let _
: Vec
<u32> = std
::intrinsics
::transmute(my_vec());
89 let _
: Vec
<u32> = std
::mem
::transmute(my_vec());
90 let _
: Vec
<u32> = my_transmute(my_vec());
92 let _
: *const usize = std
::mem
::transmute(5_isize
);
94 let _
= 5_isize
as *const usize;
96 let _
: *const usize = std
::mem
::transmute(1+1usize
);
98 let _
= (1+1_usize
) as *const usize;
104 #[warn(crosspointer_transmute)]
106 let mut int
: Usize
= Usize(0);
107 let int_const_ptr
: *const Usize
= &int
as *const Usize
;
108 let int_mut_ptr
: *mut Usize
= &mut int
as *mut Usize
;
111 let _
: Usize
= core
::intrinsics
::transmute(int_const_ptr
);
113 let _
: Usize
= core
::intrinsics
::transmute(int_mut_ptr
);
115 let _
: *const Usize
= core
::intrinsics
::transmute(my_int());
117 let _
: *mut Usize
= core
::intrinsics
::transmute(my_int());
121 #[warn(transmute_int_to_char)]
123 let _
: char = unsafe { std::mem::transmute(0_u32) }
;
124 let _
: char = unsafe { std::mem::transmute(0_i32) }
;
127 #[warn(transmute_int_to_bool)]
129 let _
: bool
= unsafe { std::mem::transmute(0_u8) }
;
132 #[warn(transmute_int_to_float)]
134 let _
: f32 = unsafe { std::mem::transmute(0_u32) }
;
135 let _
: f32 = unsafe { std::mem::transmute(0_i32) }
;
138 fn bytes_to_str(b
: &[u8], mb
: &mut [u8]) {
139 let _
: &str = unsafe { std::mem::transmute(b) }
;
140 let _
: &mut str = unsafe { std::mem::transmute(mb) }
;
143 #[warn(transmute_ptr_to_ptr)]
144 fn transmute_ptr_to_ptr() {
145 let ptr
= &1u32 as *const u32;
146 let mut_ptr
= &mut 1u32 as *mut u32;
148 // pointer-to-pointer transmutes; bad
149 let _
: *const f32 = std
::mem
::transmute(ptr
);
150 let _
: *mut f32 = std
::mem
::transmute(mut_ptr
);
151 // ref-ref transmutes; bad
152 let _
: &f32 = std
::mem
::transmute(&1u32);
153 let _
: &mut f32 = std
::mem
::transmute(&mut 1u32);
155 // These should be fine
156 let _
= ptr
as *const f32;
157 let _
= mut_ptr
as *mut f32;
158 let _
= unsafe { &*(&1u32 as *const u32 as *const f32) }
;
159 let _
= unsafe { &mut *(&mut 1u32 as *mut u32 as *mut f32) }
;