nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-24 07:44:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix unary minus on usize and unused variable errors in .fixed file

Browse Source
This commit is contained in:
Ryan1729 2020-08-09 00:28:56 -06:00
parent 0fbf450afc
commit 58b8b11791
3 changed files with 32 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.fixed
View File

@ -15,54 +15,54 @@ fn main() {
// the casts, since the casts are the recommended fixes.
// e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
let ptr_i32_transmute = unsafe {
-1 as *const i32
let _ptr_i32_transmute = unsafe {
usize::MAX as *const i32
};
let ptr_i32 = -1isize as *const i32;
let ptr_i32 = usize::MAX as *const i32;
// e has type *T, U is *U_0, and either U_0: Sized ...
let ptr_i8_transmute = unsafe {
let _ptr_i8_transmute = unsafe {
ptr_i32 as *const i8
};
let ptr_i8 = ptr_i32 as *const i8;
let _ptr_i8 = ptr_i32 as *const i8;
let slice_ptr = &[0,1,2,3] as *const [i32];
// ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
let ptr_to_unsized_transmute = unsafe {
let _ptr_to_unsized_transmute = unsafe {
slice_ptr as *const [u16]
};
let ptr_to_unsized = slice_ptr as *const [u16];
let _ptr_to_unsized = slice_ptr as *const [u16];
// TODO: We could try testing vtable casts here too, but maybe
// we should wait until std::raw::TraitObject is stabilized?
// e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
let usize_from_int_ptr_transmute = unsafe {
let _usize_from_int_ptr_transmute = unsafe {
ptr_i32 as usize
};
let usize_from_int_ptr = ptr_i32 as usize;
let _usize_from_int_ptr = ptr_i32 as usize;
let array_ref: &[i32; 4] = &[1,2,3,4];
// e has type &[T; n] and U is *const T; array-ptr-cast
let array_ptr_transmute = unsafe {
let _array_ptr_transmute = unsafe {
array_ref as *const [i32; 4]
};
let array_ptr = array_ref as *const [i32; 4];
let _array_ptr = array_ref as *const [i32; 4];
fn foo(_: usize) -> u8 { 42 }
// e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
let usize_ptr_transmute = unsafe {
let _usize_ptr_transmute = unsafe {
foo as *const usize
};
let usize_ptr_transmute = foo as *const usize;
let _usize_ptr_transmute = foo as *const usize;
// e is a function pointer type and U is an integer; fptr-addr-cast
let usize_from_fn_ptr_transmute = unsafe {
let _usize_from_fn_ptr_transmute = unsafe {
foo as usize
};
let usize_from_fn_ptr = foo as *const usize;
let _usize_from_fn_ptr = foo as *const usize;
}
// If a ref-to-ptr cast of this form where the pointer type points to a type other

30
src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs
View File

@ -15,54 +15,54 @@ fn main() {
// the casts, since the casts are the recommended fixes.
// e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
let ptr_i32_transmute = unsafe {
transmute::<isize, *const i32>(-1)
let _ptr_i32_transmute = unsafe {
transmute::<usize, *const i32>(usize::MAX)
};
let ptr_i32 = -1isize as *const i32;
let ptr_i32 = usize::MAX as *const i32;
// e has type *T, U is *U_0, and either U_0: Sized ...
let ptr_i8_transmute = unsafe {
let _ptr_i8_transmute = unsafe {
transmute::<*const i32, *const i8>(ptr_i32)
};
let ptr_i8 = ptr_i32 as *const i8;
let _ptr_i8 = ptr_i32 as *const i8;
let slice_ptr = &[0,1,2,3] as *const [i32];
// ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
let ptr_to_unsized_transmute = unsafe {
let _ptr_to_unsized_transmute = unsafe {
transmute::<*const [i32], *const [u16]>(slice_ptr)
};
let ptr_to_unsized = slice_ptr as *const [u16];
let _ptr_to_unsized = slice_ptr as *const [u16];
// TODO: We could try testing vtable casts here too, but maybe
// we should wait until std::raw::TraitObject is stabilized?
// e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
let usize_from_int_ptr_transmute = unsafe {
let _usize_from_int_ptr_transmute = unsafe {
transmute::<*const i32, usize>(ptr_i32)
};
let usize_from_int_ptr = ptr_i32 as usize;
let _usize_from_int_ptr = ptr_i32 as usize;
let array_ref: &[i32; 4] = &[1,2,3,4];
// e has type &[T; n] and U is *const T; array-ptr-cast
let array_ptr_transmute = unsafe {
let _array_ptr_transmute = unsafe {
transmute::<&[i32; 4], *const [i32; 4]>(array_ref)
};
let array_ptr = array_ref as *const [i32; 4];
let _array_ptr = array_ref as *const [i32; 4];
fn foo(_: usize) -> u8 { 42 }
// e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
let usize_ptr_transmute = unsafe {
let _usize_ptr_transmute = unsafe {
transmute::<fn(usize) -> u8, *const usize>(foo)
};
let usize_ptr_transmute = foo as *const usize;
let _usize_ptr_transmute = foo as *const usize;
// e is a function pointer type and U is an integer; fptr-addr-cast
let usize_from_fn_ptr_transmute = unsafe {
let _usize_from_fn_ptr_transmute = unsafe {
transmute::<fn(usize) -> u8, usize>(foo)
};
let usize_from_fn_ptr = foo as *const usize;
let _usize_from_fn_ptr = foo as *const usize;
}
// If a ref-to-ptr cast of this form where the pointer type points to a type other

4
src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.stderr
View File

@ -1,8 +1,8 @@
error: transmute from an integer to a pointer
--> $DIR/transmutes_expressible_as_ptr_casts.rs:19:9
|
LL | transmute::<isize, *const i32>(-1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-1 as *const i32`
LL | transmute::<usize, *const i32>(usize::MAX)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `usize::MAX as *const i32`
|
= note: `-D clippy::useless-transmute` implied by `-D warnings`