Drop intermediate cast

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2458,11 +2458,6 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   case clang::CastKind::CK_BitCast: {
     PushParen paren(*this);
     Convert(sub_expr);
-    if (type->isVoidPointerType()) {
-      StrCat(keyword::kAs,
-             type->getPointeeType().isConstQualified() ? "*const" : "*mut");
-      StrCat(ConvertPointeeType(sub_expr->getType()));
-    }
     ConvertCast(type);
     SetFreshType(type);
     break;

tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs

@@ -32,12 +32,12 @@ impl S {
         {
             if 8_usize != 0 {
                 ::std::ptr::copy_nonoverlapping(
-                    ((&mut (*_a0).n as *mut [i32; 2]) as *const [i32; 2] as *const ::libc::c_void),
-                    ((&mut self.n as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void),
+                    ((&mut (*_a0).n as *mut [i32; 2]) as *const ::libc::c_void),
+                    ((&mut self.n as *mut [i32; 2]) as *mut ::libc::c_void),
                     8_usize as usize,
                 )
             }
-            ((&mut self.n as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void)
+            ((&mut self.n as *mut [i32; 2]) as *mut ::libc::c_void)
         };
         return &mut (*(self as *mut S));
     }

tests/ub/out/unsafe/fd_use_after_close.rs

@@ -23,7 +23,7 @@ unsafe fn main_0() -> i32 {
     let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4];
     let mut n: isize = libc::read(
         fd,
-        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+        (buf.as_mut_ptr() as *mut ::libc::c_void),
         ::std::mem::size_of::<[libc::c_char; 4]>(),
     );
     return if ((((n) == (-1_i32 as isize)) as i32) != 0) {

tests/unit/out/unsafe/bsearch_ptr_cmp.rs

@@ -18,8 +18,8 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a1: [i32; 3] = [1, 2, 3];
     let mut vptr1: *mut ::libc::c_void = libc::bsearch(
-        ((&mut a1[(0) as usize] as *mut i32) as *const i32 as *const ::libc::c_void),
-        (a1.as_mut_ptr() as *const i32 as *const ::libc::c_void),
+        ((&mut a1[(0) as usize] as *mut i32) as *const ::libc::c_void),
+        (a1.as_mut_ptr() as *const ::libc::c_void),
         1_usize,
         ::std::mem::size_of::<i32>(),
         Some(std::mem::transmute::<
@@ -30,7 +30,7 @@ unsafe fn main_0() -> i32 {
                 as *const (),
         )),
     );
-    assert!(((vptr1) == ((&mut a1[(0) as usize] as *mut i32) as *mut i32 as *mut ::libc::c_void)));
+    assert!(((vptr1) == ((&mut a1[(0) as usize] as *mut i32) as *mut ::libc::c_void)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/copy_move_defaulted.rs

@@ -150,13 +150,12 @@ impl Buffer {
         {
             if 8_usize != 0 {
                 ::std::ptr::copy_nonoverlapping(
-                    ((&mut (*_a0).arr as *mut [i32; 2]) as *const [i32; 2]
-                        as *const ::libc::c_void),
-                    ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void),
+                    ((&mut (*_a0).arr as *mut [i32; 2]) as *const ::libc::c_void),
+                    ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void),
                     8_usize as usize,
                 )
             }
-            ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void)
+            ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void)
         };
         return &mut (*(self as *mut Buffer));
     }
@@ -195,13 +194,12 @@ impl Owner {
         {
             if 8_usize != 0 {
                 ::std::ptr::copy_nonoverlapping(
-                    ((&mut (*_a0).arr as *mut [i32; 2]) as *const [i32; 2]
-                        as *const ::libc::c_void),
-                    ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void),
+                    ((&mut (*_a0).arr as *mut [i32; 2]) as *const ::libc::c_void),
+                    ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void),
                     8_usize as usize,
                 )
             }
-            ((&mut self.arr as *mut [i32; 2]) as *mut [i32; 2] as *mut ::libc::c_void)
+            ((&mut self.arr as *mut [i32; 2]) as *mut ::libc::c_void)
         };
         self.p = (*_a0).p.take();
         return &mut (*(self as *mut Owner));

tests/unit/out/unsafe/cstring.rs

@@ -19,14 +19,14 @@ pub unsafe fn test_memcpy_0() {
     let mut r: *mut ::libc::c_void = {
         if 6_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (src.as_ptr() as *const libc::c_char as *const ::libc::c_void),
-                (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+                (src.as_ptr() as *const ::libc::c_void),
+                (dst.as_mut_ptr() as *mut ::libc::c_void),
                 6_usize as usize,
             )
         }
-        (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
+        (dst.as_mut_ptr() as *mut ::libc::c_void)
     };
-    assert!(((r) == (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)));
+    assert!(((r) == (dst.as_mut_ptr() as *mut ::libc::c_void)));
     assert!(
         (((dst[(0) as usize] as i32) == (('h' as libc::c_char) as i32))
             && ((dst[(1) as usize] as i32) == (('e' as libc::c_char) as i32)))
@@ -41,13 +41,13 @@ pub unsafe fn test_memcpy_0() {
 pub unsafe fn test_memset_1() {
     let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4];
     let mut r: *mut ::libc::c_void = {
-        let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+        let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8;
         for offset in 0..4_usize {
             *byte_0.offset(offset as isize) = (('x' as libc::c_char) as i32) as u8;
         }
-        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
+        (buf.as_mut_ptr() as *mut ::libc::c_void)
     };
-    assert!(((r) == (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)));
+    assert!(((r) == (buf.as_mut_ptr() as *mut ::libc::c_void)));
     assert!(
         ((((buf[(0) as usize] as i32) == (('x' as libc::c_char) as i32))
             && ((buf[(1) as usize] as i32) == (('x' as libc::c_char) as i32)))
@@ -77,11 +77,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (b.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (b.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -97,11 +97,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -117,11 +117,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -147,17 +147,14 @@ pub unsafe fn test_memmove_3() {
     let mut r: *mut ::libc::c_void = {
         if 4_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
-                (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void),
+                (buf.as_mut_ptr() as *const ::libc::c_void),
+                (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void),
                 4_usize as usize,
             )
         }
-        (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void)
+        (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void)
     };
-    assert!(
-        ((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char
-            as *mut ::libc::c_void))
-    );
+    assert!(((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut ::libc::c_void)));
     assert!(
         (((buf[(0) as usize] as i32) == (('a' as libc::c_char) as i32))
             && ((buf[(1) as usize] as i32) == (('a' as libc::c_char) as i32)))
@@ -226,25 +223,20 @@ pub unsafe fn test_memchr_8() {
         (64 as libc::c_char),
     ];
     let mut r: *const ::libc::c_void = libc::memchr(
-        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const ::libc::c_void,
+        (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void,
         48,
         4_usize as usize,
     ) as *const ::libc::c_void;
-    assert!(
-        ((r) == ((&data[(2) as usize] as *const libc::c_char) as *const libc::c_char
-            as *const ::libc::c_void))
-    );
+    assert!(((r) == ((&data[(2) as usize] as *const libc::c_char) as *const ::libc::c_void)));
     assert!(
         (libc::memchr(
-            (data.as_ptr() as *const libc::c_char as *const ::libc::c_void)
-                as *const ::libc::c_void,
+            (data.as_ptr() as *const ::libc::c_void) as *const ::libc::c_void,
             153,
             4_usize as usize
         ) as *const ::libc::c_void)
             .is_null()
     );
-    let mut p: *const ::libc::c_void =
-        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void);
+    let mut p: *const ::libc::c_void = (data.as_ptr() as *const ::libc::c_void);
     let mut n: usize = 4_usize;
     assert!(
         ((libc::memchr(p as *const ::libc::c_void, 16, n as usize) as *const ::libc::c_void)
@@ -274,7 +266,7 @@ pub unsafe fn test_strdup_10() {
     let mut d: *mut libc::c_char = libcc2rs::strdup_unsafe(c"hello".as_ptr());
     assert!(!((d).is_null()));
     assert!(((libc::strcmp((d).cast_const(), c"hello".as_ptr())) == (0)));
-    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut ::libc::c_void));
     let mut p: *const libc::c_char = c"world".as_ptr();
     let mut buf: [libc::c_char; 4] = [
         ('a' as libc::c_char),
@@ -285,11 +277,11 @@ pub unsafe fn test_strdup_10() {
     let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p);
     assert!(!((d2).is_null()));
     assert!(((libc::strcmp((d2).cast_const(), p)) == (0)));
-    libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d2 as *mut ::libc::c_void));
     let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
     assert!(!((d3).is_null()));
     assert!(((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)));
-    libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d3 as *mut ::libc::c_void));
 }
 pub unsafe fn test_strcspn_11() {
     assert!(((libc::strcspn(c"hello".as_ptr(), c"el".as_ptr())) == (1_usize)));

tests/unit/out/unsafe/errno.rs

@@ -21,7 +21,7 @@ pub unsafe fn test_errno_preserved_across_strdup_1() {
         libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const());
     assert!((((!((d).is_null())) as i32) != 0));
     assert!(((((*libcc2rs::cpp2rust_errno_unsafe()) == (99)) as i32) != 0));
-    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut ::libc::c_void));
     (*libcc2rs::cpp2rust_errno_unsafe()) = 0;
 }
 pub unsafe fn test_errno_from_fseek_2() {

tests/unit/out/unsafe/fcntl.rs

@@ -34,7 +34,7 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((((libc::read(
             fds[(0) as usize],
-            ((&mut b as *mut libc::c_char) as *mut libc::c_char as *mut ::libc::c_void),
+            ((&mut b as *mut libc::c_char) as *mut ::libc::c_void),
             1_usize
         )) == (-1_i32 as isize)) as i32)
             != 0)

tests/unit/out/unsafe/fd_io.rs

@@ -26,7 +26,7 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((((libc::write(
             fd,
-            (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void),
+            (c"hello world".as_ptr().cast_mut() as *const ::libc::c_void),
             11_usize
         )) == (11_isize)) as i32)
             != 0)
@@ -36,16 +36,16 @@ unsafe fn main_0() -> i32 {
     assert!(((((fd) >= (0)) as i32) != 0));
     let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16];
     {
-        let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+        let byte_0 = (buf.as_mut_ptr() as *mut ::libc::c_void) as *mut u8;
         for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() {
             *byte_0.offset(offset as isize) = 0 as u8;
         }
-        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
+        (buf.as_mut_ptr() as *mut ::libc::c_void)
     };
     assert!(
         ((((libc::read(
             fd,
-            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut ::libc::c_void),
             ::std::mem::size_of::<[libc::c_char; 16]>()
         )) == (11_isize)) as i32)
             != 0)
@@ -60,7 +60,7 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((((libc::read(
             fd,
-            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut ::libc::c_void),
             ::std::mem::size_of::<[libc::c_char; 16]>()
         )) == (0_isize)) as i32)
             != 0)

tests/unit/out/unsafe/fn_ptr.rs

@@ -13,7 +13,7 @@ pub unsafe fn foo_1(
     mut fn_: Option<unsafe fn(*mut ::libc::c_void) -> i32>,
     mut pi: *mut i32,
 ) -> i32 {
-    return (unsafe { (fn_).unwrap()((pi as *mut i32 as *mut ::libc::c_void)) });
+    return (unsafe { (fn_).unwrap()((pi as *mut ::libc::c_void)) });
 }
 pub fn main() {
     unsafe {