iterate List by value

[rust.git] / tests / ui / transmute.rs

diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 4f0c2f5a895cbf76a685205a4fddea933d990b83..bb853d237047fbc33f6bd85b50c04ad8f2e5edf2 100644 (file)
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -27,46 +27,6 @@ unsafe fn _generic<'a, T, U: 'a>(t: &'a T) {
     let _: *const U = core::intrinsics::transmute(t);
 }
 
-#[warn(clippy::transmute_ptr_to_ref)]
-unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
-    let _: &T = std::mem::transmute(p);
-    let _: &T = &*p;
-
-    let _: &mut T = std::mem::transmute(m);
-    let _: &mut T = &mut *m;
-
-    let _: &T = std::mem::transmute(m);
-    let _: &T = &*m;
-
-    let _: &mut T = std::mem::transmute(p as *mut T);
-    let _ = &mut *(p as *mut T);
-
-    let _: &T = std::mem::transmute(o);
-    let _: &T = &*(o as *const T);
-
-    let _: &mut T = std::mem::transmute(om);
-    let _: &mut T = &mut *(om as *mut T);
-
-    let _: &T = std::mem::transmute(om);
-    let _: &T = &*(om as *const T);
-}
-
-#[warn(clippy::transmute_ptr_to_ref)]
-fn issue1231() {
-    struct Foo<'a, T> {
-        bar: &'a T,
-    }
-
-    let raw = 42 as *const i32;
-    let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
-
-    let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };
-
-    type Bar<'a> = &'a u8;
-    let raw = 42 as *const i32;
-    unsafe { std::mem::transmute::<_, Bar>(raw) };
-}
-
 #[warn(clippy::useless_transmute)]
 fn useless() {
     unsafe {
@@ -131,58 +91,4 @@ fn bytes_to_str(b: &[u8], mb: &mut [u8]) {
     let _: &mut str = unsafe { std::mem::transmute(mb) };
 }
 
-// Make sure we can modify lifetimes, which is one of the recommended uses
-// of transmute
-
-// Make sure we can do static lifetime transmutes
-#[warn(clippy::transmute_ptr_to_ptr)]
-unsafe fn transmute_lifetime_to_static<'a, T>(t: &'a T) -> &'static T {
-    std::mem::transmute::<&'a T, &'static T>(t)
-}
-
-// Make sure we can do non-static lifetime transmutes
-#[warn(clippy::transmute_ptr_to_ptr)]
-unsafe fn transmute_lifetime<'a, 'b, T>(t: &'a T, u: &'b T) -> &'b T {
-    std::mem::transmute::<&'a T, &'b T>(t)
-}
-
-struct LifetimeParam<'a> {
-    s: &'a str,
-}
-
-struct GenericParam<T> {
-    t: T,
-}
-
-#[warn(clippy::transmute_ptr_to_ptr)]
-fn transmute_ptr_to_ptr() {
-    let ptr = &1u32 as *const u32;
-    let mut_ptr = &mut 1u32 as *mut u32;
-    unsafe {
-        // pointer-to-pointer transmutes; bad
-        let _: *const f32 = std::mem::transmute(ptr);
-        let _: *mut f32 = std::mem::transmute(mut_ptr);
-        // ref-ref transmutes; bad
-        let _: &f32 = std::mem::transmute(&1u32);
-        let _: &f64 = std::mem::transmute(&1f32);
-        // ^ this test is here because both f32 and f64 are the same TypeVariant, but they are not
-        // the same type
-        let _: &mut f32 = std::mem::transmute(&mut 1u32);
-        let _: &GenericParam<f32> = std::mem::transmute(&GenericParam { t: 1u32 });
-    }
-
-    // these are recommendations for solving the above; if these lint we need to update
-    // those suggestions
-    let _ = ptr as *const f32;
-    let _ = mut_ptr as *mut f32;
-    let _ = unsafe { &*(&1u32 as *const u32 as *const f32) };
-    let _ = unsafe { &mut *(&mut 1u32 as *mut u32 as *mut f32) };
-
-    // transmute internal lifetimes, should not lint
-    let s = "hello world".to_owned();
-    let lp = LifetimeParam { s: &s };
-    let _: &LifetimeParam<'static> = unsafe { std::mem::transmute(&lp) };
-    let _: &GenericParam<&LifetimeParam<'static>> = unsafe { std::mem::transmute(&GenericParam { t: &lp }) };
-}
-
 fn main() {}