Skip cast when reference coerces to pointer

cpp2rust/converter/converter.cpp

@@ -4003,10 +4003,6 @@ void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
     PushInitType init_type(*this, qual_type);
     Convert(expr, qual_type);
   }
-  if (qual_type->isReferenceType() && !IsReferenceType(expr)) {
-    StrCat(keyword::kAs);
-    Convert(qual_type);
-  }
 }
 
 void Converter::ConvertUnsignedArithOperand(clang::Expr *expr,

tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs

@@ -16,7 +16,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 2];
-    let b: *const i32 = (unsafe { foo_0(&(*v.as_mut_ptr()) as *const i32) });
+    let b: *const i32 = (unsafe { foo_0(&(*v.as_mut_ptr())) });
     v.clear();
     return (*b);
 }

tests/ub/out/unsafe/ub1.rs

@@ -9,7 +9,7 @@ use std::rc::Rc;
 pub unsafe fn dangling_0() -> *mut i32 {
     let mut x: i32 = 1;
     let mut p: *mut i32 = (&mut x as *mut i32);
-    return &mut (*p) as *mut i32;
+    return &mut (*p);
 }
 pub fn main() {
     unsafe {

tests/ub/out/unsafe/ub4.rs

@@ -19,7 +19,7 @@ unsafe fn main_0() -> i32 {
     let mut x1: i32 = 1;
     if (x1 != 0) {
         let mut x2: i32 = -1_i32;
-        out = (unsafe { smaller_0(&mut x1 as *mut i32, &mut x2 as *mut i32) });
+        out = (unsafe { smaller_0(&mut x1, &mut x2) });
     }
     return (*out);
 }

tests/ub/out/unsafe/ub5.rs

@@ -18,6 +18,6 @@ unsafe fn main_0() -> i32 {
     let mut x: i32 = 1;
     let mut p: *mut i32 = (&mut x as *mut i32);
     (unsafe { null_0((&mut p as *mut *mut i32)) });
-    let r: *mut i32 = &mut (*p) as *mut i32;
+    let r: *mut i32 = &mut (*p);
     return (*r);
 }

tests/ub/out/unsafe/ub6.rs

@@ -19,7 +19,7 @@ pub unsafe fn fill_1(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) {
     let mut n2: i32 = (*n1);
     let mut pair: Pair = (unsafe {
         let _x1: *mut i32 = n1;
-        let _x2: *mut i32 = &mut n2 as *mut i32;
+        let _x2: *mut i32 = &mut n2;
         mkPair_0(_x1, _x2)
     });
     (*arr).as_mut().unwrap()[(0_usize)] = (pair.x1);
@@ -46,7 +46,6 @@ unsafe fn main_0() -> i32 {
             .map(|_| <*mut i32>::default())
             .collect::<Box<[_]>>(),
     );
-    (unsafe { fill_1(&mut arr as *mut Option<Box<[*mut i32]>>, &mut n as *mut i32) });
-    return ((unsafe { any_2(&mut arr as *mut Option<Box<[*mut i32]>>, &mut n as *mut i32) })
-        as i32);
+    (unsafe { fill_1(&mut arr, &mut n) });
+    return ((unsafe { any_2(&mut arr, &mut n) }) as i32);
 }

tests/unit/out/unsafe/04_address_taken_array.rs

@@ -18,7 +18,7 @@ unsafe fn main_0() -> i32 {
     let mut arr2_ptr: *mut i32 = arr2.as_mut_ptr();
     (*arr2_ptr.offset((0) as isize)) = 5;
     (*arr2_ptr.offset((1) as isize)) = 6;
-    let arr2_ref1: *mut i32 = &mut arr2[(1) as usize] as *mut i32;
+    let arr2_ref1: *mut i32 = &mut arr2[(1) as usize];
     (*arr2_ref1) = 7;
     assert!((((arr2[(0) as usize]) + (arr2[(1) as usize])) == (12)));
     return 0;

tests/unit/out/unsafe/09_references.rs

@@ -13,10 +13,10 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut h: i32 = 15;
-    let h_ref1: *mut i32 = &mut h as *mut i32;
+    let h_ref1: *mut i32 = &mut h;
     (*h_ref1) = 16;
     let mut h_ptr: *mut i32 = (h_ref1);
-    let h_ref2: *mut i32 = &mut (*h_ptr) as *mut i32;
+    let h_ref2: *mut i32 = &mut (*h_ptr);
     (*h_ref2) = 17;
     assert!((((*h_ref1) + (*h_ref2)) == (34)));
     return 0;

tests/unit/out/unsafe/11_move.rs

@@ -22,7 +22,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut n: Option<Box<i32>> = Some(Box::new(10));
-    (unsafe { change_0(&mut n as *mut Option<Box<i32>>) });
+    (unsafe { change_0(&mut n) });
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }

tests/unit/out/unsafe/13_testing.rs

@@ -13,7 +13,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: i32 = 1;
-    let r: *mut i32 = &mut a as *mut i32;
+    let r: *mut i32 = &mut a;
     let mut p: *mut i32 = (&mut a as *mut i32);
     (*r) = 2;
     (*p) = 3;

tests/unit/out/unsafe/alloc_array.rs

@@ -39,7 +39,7 @@ unsafe fn main_0() -> i32 {
             .map(|_| <i32>::default())
             .collect::<Box<[_]>>(),
     );
-    (unsafe { All_0(&mut arr as *mut Option<Box<[i32]>>, N, 1) });
+    (unsafe { All_0(&mut arr, N, 1) });
     assert!(((unsafe { Consume_1(arr.take(), N,) }) == (10)));
     return 0;
 }

tests/unit/out/unsafe/array_reference.rs

@@ -68,36 +68,32 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(
-        ((unsafe { len_0(&std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5],) }) == (4))
-    );
+    assert!(((unsafe { len_0(&std::mem::transmute(*b"beta\0"),) }) == (4)));
     let mut buf: [libc::c_char; 5] = std::mem::transmute(*b"abcd\0");
-    assert!(((unsafe { len_0(&buf as *const [libc::c_char; 5],) }) == (4)));
+    assert!(((unsafe { len_0(&buf,) }) == (4)));
     let mut arr: [i32; 3] = [1, 2, 3];
-    assert!(((unsafe { sum_2(&arr as *const [i32; 3],) }) == (6)));
-    (unsafe { fill_3(&mut arr as *mut [i32; 3], 7) });
-    assert!(((unsafe { sum_2(&arr as *const [i32; 3],) }) == (21)));
-    assert!(((unsafe { sum_twice_4(&arr as *const [i32; 3],) }) == (42)));
+    assert!(((unsafe { sum_2(&arr,) }) == (6)));
+    (unsafe { fill_3(&mut arr, 7) });
+    assert!(((unsafe { sum_2(&arr,) }) == (21)));
+    assert!(((unsafe { sum_twice_4(&arr,) }) == (42)));
     let mut out: i32 = 0;
-    (unsafe { fill_and_sum_5(&mut arr as *mut [i32; 3], 2, &mut out as *mut i32) });
+    (unsafe { fill_and_sum_5(&mut arr, 2, &mut out) });
     assert!(((out) == (12)));
     assert!(((arr[(0) as usize]) == (2)));
-    let lit: *const [libc::c_char; 5] =
-        &std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5];
+    let lit: *const [libc::c_char; 5] = &std::mem::transmute(*b"beta\0");
     assert!(((unsafe { len_0(lit,) }) == (4)));
     assert!(
-        (((*(unsafe { pick_6(&std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5],) }))
-            [(0) as usize] as i32)
+        (((*(unsafe { pick_6(&std::mem::transmute(*b"beta\0"),) }))[(0) as usize] as i32)
             == (('b' as libc::c_char) as i32))
     );
-    assert!(((unsafe { len_0((unsafe { pick_6(&buf as *const [libc::c_char; 5],) }),) }) == (4)));
+    assert!(((unsafe { len_0((unsafe { pick_6(&buf,) }),) }) == (4)));
     let mut pts: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
-    assert!(((unsafe { sum_points_7(&pts as *const [Point; 2],) }) == (10)));
-    (unsafe { shift_points_8(&mut pts as *mut [Point; 2], 10) });
+    assert!(((unsafe { sum_points_7(&pts,) }) == (10)));
+    (unsafe { shift_points_8(&mut pts, 10) });
     assert!(((pts[(0) as usize].x) == (11)));
     assert!(((pts[(1) as usize].y) == (14)));
-    assert!(((unsafe { sum_points_7(&pts as *const [Point; 2],) }) == (30)));
+    assert!(((unsafe { sum_points_7(&pts,) }) == (30)));
     let mut names: [*const libc::c_char; 2] = [c"ab".as_ptr(), c"cde".as_ptr()];
-    assert!(((unsafe { total_len_9(&mut names as *mut [*const libc::c_char; 2],) }) == (5)));
+    assert!(((unsafe { total_len_9(&mut names,) }) == (5)));
     return 0;
 }

tests/unit/out/unsafe/borrow_mut_opt.rs

@@ -32,7 +32,7 @@ pub unsafe fn convert_without_rhs_0() {
     c = arr2[(*p1) as usize];
     let mut p2: *mut i32 = (&mut x as *mut i32);
     (*p2) = 1;
-    let r: *mut i32 = &mut x as *mut i32;
+    let r: *mut i32 = &mut x;
     (*r) = 1;
 }
 pub unsafe fn convert_with_rhs_1() {
@@ -44,7 +44,7 @@ pub unsafe fn convert_with_rhs_1() {
     arr[(y) as usize] = ((y) + (1));
     arr[(x) as usize] = ((x) + (1));
     arr[(x) as usize] = ((arr[(y) as usize]) + (1));
-    let z: *mut i32 = &mut x as *mut i32;
+    let z: *mut i32 = &mut x;
     x += (*z);
     y += (*z);
     let mut p: *mut i32 = (&mut x as *mut i32);

tests/unit/out/unsafe/class.rs

@@ -29,14 +29,14 @@ impl Pair {
     pub unsafe fn SetFirst(&mut self, mut new_first: i32) -> i32 {
         return ((unsafe { Pair::GetFirst(self) })
             + (unsafe {
-                let _field: *mut i32 = &mut self.first as *mut i32;
+                let _field: *mut i32 = &mut self.first;
                 Pair::Set(self, _field, new_first)
             }));
     }
     pub unsafe fn SetSecond(&mut self, mut new_second: i32) -> i32 {
         return ((unsafe { Pair::GetSecond(self) })
             + (unsafe {
-                let _field: *mut i32 = &mut self.second as *mut i32;
+                let _field: *mut i32 = &mut self.second;
                 Pair::Set(self, _field, new_second)
             }));
     }
@@ -95,8 +95,8 @@ unsafe fn main_0() -> i32 {
         )
     });
     assert!(
-        (((((unsafe { RandomRoute_0(&mut route1 as *mut Route,) })
-            + (unsafe { RandomRoute_0(&mut route2 as *mut Route,) })) as f64)
+        (((((unsafe { RandomRoute_0(&mut route1,) }) + (unsafe { RandomRoute_0(&mut route2,) }))
+            as f64)
             + (old_cost))
             == (9_f64))
     );

tests/unit/out/unsafe/clone_vs_move.rs

@@ -47,7 +47,7 @@ unsafe fn main_0() -> i32 {
     x4.prefix_inc();
     assert!(((x3) == (3.0E+0)));
     assert!(((x4) == (4.0E+0)));
-    let reference: *mut i32 = &mut x1 as *mut i32;
+    let reference: *mut i32 = &mut x1;
     let mut x5: i32 = (*reference);
     x5.prefix_inc();
     assert!(((*reference) == (1)));
@@ -63,7 +63,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*other_pointer) == (*pointer)));
     let mut f1: Foo = Foo {
         x: 1,
-        y: &mut x1 as *mut i32,
+        y: &mut x1,
         z: (&mut x1 as *mut i32),
         a: [0, 1, 2],
         bar: Bar { w: 10 },

tests/unit/out/unsafe/complex_function.rs

@@ -47,7 +47,7 @@ pub struct X4 {
 }
 impl X4 {
     pub unsafe fn get(&mut self) -> *mut X3 {
-        return &mut self.v as *mut X3;
+        return &mut self.v;
     }
 }
 pub fn main() {
@@ -66,17 +66,15 @@ unsafe fn main_0() -> i32 {
     let mut p2: *mut i32 = (unsafe { ptr_1(p1) });
     p1 = p2;
     p2 = (unsafe { ptr_1(p1) });
-    let r1: *mut i32 = &mut x1 as *mut i32;
-    let r2: *mut i32 = (unsafe { bar_2(&mut x1 as *mut i32) });
+    let r1: *mut i32 = &mut x1;
+    let r2: *mut i32 = (unsafe { bar_2(&mut x1) });
     let r3: *mut i32 = (unsafe { bar_2(r1) });
     (*r2) += x1;
     (*r3) += (*r1);
     let mut x4: i32 = (((unsafe { foo_0(x3) }) + (*(unsafe { ptr_1((&mut x3 as *mut i32)) })))
-        + (*(unsafe { bar_2(&mut x2 as *mut i32) })));
+        + (*(unsafe { bar_2(&mut x2) })));
     let mut a: X1 = X1 { v: 0 };
-    let mut b: X2 = X2 {
-        v: &mut a as *mut X1,
-    };
+    let mut b: X2 = X2 { v: &mut a };
     let mut c: X3 = X3 {
         v: (&mut b as *mut X2),
     };
@@ -88,44 +86,43 @@ unsafe fn main_0() -> i32 {
     let r4: *const i32 = &(*(unsafe {
         X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
     }))
-    .v as *const i32;
+    .v;
     let r5: *mut X1 =
         (unsafe { X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) }))) });
     let mut p: *mut X2 = (unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) });
     let r6: *mut X3 = (unsafe { X4::get(&mut d) });
-    let r7: *mut X3 = &mut d.v as *mut X3;
-    let r8: *mut i32 =
-        &mut (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut d.v) }))) })).v as *mut i32;
+    let r7: *mut X3 = &mut d.v;
+    let r8: *mut i32 = &mut (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut d.v) }))) })).v;
     let mut x5: i32 =
         (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) }))) }))
             .v;
-    (*(unsafe { bar_2(&mut x1 as *mut i32) })) += 10;
-    (*(unsafe { bar_2(&mut x1 as *mut i32) })).postfix_inc();
+    (*(unsafe { bar_2(&mut x1) })) += 10;
+    (*(unsafe { bar_2(&mut x1) })).postfix_inc();
     let mut bar_out: i32 = (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }));
-    let mut bar_inc: i32 = (*(unsafe { bar_2(&mut x1 as *mut i32) })).prefix_inc();
-    bar_inc = (*(unsafe { bar_2(&mut x1 as *mut i32) })).postfix_inc();
-    bar_inc = (((*(unsafe { bar_2(&mut x1 as *mut i32) })) + (unsafe { foo_0(x4) })) + (1));
+    let mut bar_inc: i32 = (*(unsafe { bar_2(&mut x1) })).prefix_inc();
+    bar_inc = (*(unsafe { bar_2(&mut x1) })).postfix_inc();
+    bar_inc = (((*(unsafe { bar_2(&mut x1) })) + (unsafe { foo_0(x4) })) + (1));
     (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     })) += 10;
     (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -134,7 +131,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .prefix_inc();
@@ -143,7 +140,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -190,7 +187,7 @@ unsafe fn main_0() -> i32 {
             }))
             .v as *mut i32),
         )
-    })) as *mut i32;
+    }));
     let mut ptr3: *mut i32 = (&mut (*(unsafe {
         ptr_1(
             (&mut (*(unsafe {
@@ -212,15 +209,15 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     });
     (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -237,7 +234,7 @@ unsafe fn main_0() -> i32 {
                 &mut (*(unsafe {
                     X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
                 }))
-                .v as *mut i32,
+                .v,
             )
         }))) + (unsafe {
             foo_0(