Delete array subscript cast if type is already usize

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3637,7 +3637,10 @@ void Converter::ConvertArraySubscript(clang::Expr *base, clang::Expr *idx,
     PushParen paren(*this);
     Convert(idx);
   }
-  StrCat(keyword::kAs, "usize");
+
+  if (Mapper::Map(idx->getType()) != "usize") {
+    StrCat(keyword::kAs, "usize");
+  }
 }
 
 void Converter::ConvertAssignment(clang::Expr *lhs, clang::Expr *rhs,

tests/ub/out/unsafe/ub6.rs

@@ -22,14 +22,14 @@ pub unsafe fn fill_1(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) {
         let _x2: *mut i32 = &mut n2 as *mut i32;
         mkPair_0(_x1, _x2)
     });
-    (*arr).as_mut().unwrap()[(0_usize) as usize] = (pair.x1);
-    (*arr).as_mut().unwrap()[(1_usize) as usize] = (pair.x2);
+    (*arr).as_mut().unwrap()[(0_usize)] = (pair.x1);
+    (*arr).as_mut().unwrap()[(1_usize)] = (pair.x2);
 }
 pub unsafe fn any_2(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) -> bool {
     let mut out: bool = false;
     let mut i: i32 = 0;
     'loop_: while ((i) < (*n1)) {
-        out = (out) || ((*(*arr).as_mut().unwrap()[(i as usize) as usize]) == (0));
+        out = (out) || ((*(*arr).as_mut().unwrap()[(i as usize)]) == (0));
         i.prefix_inc();
     }
     return out;

tests/unit/out/unsafe/08_unique_array.rs

@@ -14,12 +14,12 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut g: Option<Box<[i32]>> =
         Some((0..2_usize).map(|_| <i32>::default()).collect::<Box<[_]>>());
-    g.as_mut().unwrap()[(0_usize) as usize] = 11;
-    g.as_mut().unwrap()[(1_usize) as usize] = 12;
+    g.as_mut().unwrap()[(0_usize)] = 11;
+    g.as_mut().unwrap()[(1_usize)] = 12;
     let mut g_ptr: *mut i32 = g
         .as_deref_mut()
         .map_or(::std::ptr::null_mut(), |s| s.as_mut_ptr());
     (*g_ptr.offset((0) as isize)) = 13;
     (*g_ptr.offset((1) as isize)) = 14;
-    return ((g.as_mut().unwrap()[(0_usize) as usize]) + (g.as_mut().unwrap()[(1_usize) as usize]));
+    return ((g.as_mut().unwrap()[(0_usize)]) + (g.as_mut().unwrap()[(1_usize)]));
 }

tests/unit/out/unsafe/alloc_array.rs

@@ -14,7 +14,7 @@ pub unsafe fn All_0(arr: *mut Option<Box<[i32]>>, mut N: i32, mut element: i32)
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        all.as_mut().unwrap()[(i as usize) as usize] = element;
+        all.as_mut().unwrap()[(i as usize)] = element;
         i.prefix_inc();
     }
     (*arr) = all;
@@ -23,7 +23,7 @@ pub unsafe fn Consume_1(mut arr: Option<Box<[i32]>>, mut N: i32) -> i32 {
     let mut sum: i32 = 0;
     let mut i: i32 = -1_i32;
     'loop_: while ((i.prefix_inc()) < (N)) {
-        sum += arr.as_mut().unwrap()[(i as usize) as usize];
+        sum += arr.as_mut().unwrap()[(i as usize)];
     }
     return sum;
 }

tests/unit/out/unsafe/char_printing.rs

@@ -38,8 +38,8 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize) as usize]] as &[u8]),
-            (&[vec_[(1_usize) as usize]] as &[u8]),
+            (&[vec_[(0_usize)]] as &[u8]),
+            (&[vec_[(1_usize)]] as &[u8]),
             (&[('o' as u8)] as &[u8]),
             (&(str)[..(str).len() - 1] as &[u8]),
             (&[b'\n'] as &[u8]),
@@ -102,9 +102,9 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize) as usize]] as &[u8]),
+            (&[vec_[(0_usize)]] as &[u8]),
             (&[('\n' as u8)] as &[u8]),
-            (&[vec_[(1_usize) as usize]] as &[u8]),
+            (&[vec_[(1_usize)]] as &[u8]),
             (&[('\n' as u8)] as &[u8]),
         ]
         .concat()),

tests/unit/out/unsafe/char_printing_cerr.rs

@@ -38,8 +38,8 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize) as usize]] as &[u8]),
-            (&[vec_[(1_usize) as usize]] as &[u8]),
+            (&[vec_[(0_usize)]] as &[u8]),
+            (&[vec_[(1_usize)]] as &[u8]),
             (&[('o' as u8)] as &[u8]),
             (&(str)[..(str).len() - 1] as &[u8]),
             (&[b'\n'] as &[u8]),
@@ -102,9 +102,9 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize) as usize]] as &[u8]),
+            (&[vec_[(0_usize)]] as &[u8]),
             (&[('\n' as u8)] as &[u8]),
-            (&[vec_[(1_usize) as usize]] as &[u8]),
+            (&[vec_[(1_usize)]] as &[u8]),
             (&[('\n' as u8)] as &[u8]),
         ]
         .concat()),

tests/unit/out/unsafe/clone_vs_move.rs

@@ -111,18 +111,18 @@ unsafe fn main_0() -> i32 {
     let mut v2: Vec<i32> = v1.clone();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((v2[(i as usize) as usize]) == (i)));
+        assert!(((v2[(i as usize)]) == (i)));
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        v2[(i as usize) as usize].prefix_inc();
+        v2[(i as usize)].prefix_inc();
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((v2[(i as usize) as usize]) == ((i) + (1))));
-        assert!(((v1[(i as usize) as usize]) == (i)));
+        assert!(((v2[(i as usize)]) == ((i) + (1))));
+        assert!(((v1[(i as usize)]) == (i)));
         i.prefix_inc();
     }
     let mut m1: Vec<Vec<i32>> = Vec::new();
@@ -138,12 +138,12 @@ unsafe fn main_0() -> i32 {
     let mut m2: Vec<Vec<i32>> = m1.clone();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((m1[(i as usize) as usize].len()) == (10_usize)));
-        assert!(((m2[(i as usize) as usize].len()) == (10_usize)));
+        assert!(((m1[(i as usize)].len()) == (10_usize)));
+        assert!(((m2[(i as usize)].len()) == (10_usize)));
         let mut j: i32 = 0;
         'loop_: while ((j) < (10)) {
-            assert!(((m1[(i as usize) as usize][(j as usize) as usize]) == (0)));
-            assert!(((m2[(i as usize) as usize][(j as usize) as usize]) == (0)));
+            assert!(((m1[(i as usize)][(j as usize)]) == (0)));
+            assert!(((m2[(i as usize)][(j as usize)]) == (0)));
             j.prefix_inc();
         }
         i.prefix_inc();
@@ -152,19 +152,19 @@ unsafe fn main_0() -> i32 {
     'loop_: while ((i) < (N)) {
         let mut j: i32 = 0;
         'loop_: while ((j) < (10)) {
-            m2[(i as usize) as usize][(j as usize) as usize].postfix_inc();
+            m2[(i as usize)][(j as usize)].postfix_inc();
             j.prefix_inc();
         }
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((m1[(i as usize) as usize].len()) == (10_usize)));
-        assert!(((m2[(i as usize) as usize].len()) == (10_usize)));
+        assert!(((m1[(i as usize)].len()) == (10_usize)));
+        assert!(((m2[(i as usize)].len()) == (10_usize)));
         let mut j: i32 = 0;
         'loop_: while ((j) < (10)) {
-            assert!(((m1[(i as usize) as usize][(j as usize) as usize]) == (0)));
-            assert!(((m2[(i as usize) as usize][(j as usize) as usize]) == (1)));
+            assert!(((m1[(i as usize)][(j as usize)]) == (0)));
+            assert!(((m2[(i as usize)][(j as usize)]) == (1)));
             j.prefix_inc();
         }
         i.prefix_inc();
@@ -216,15 +216,15 @@ unsafe fn main_0() -> i32 {
         .chain(std::iter::once(0))
         .collect();
     let mut s2: Vec<u8> = s1.clone();
-    s2[(0_usize) as usize] = ('b' as u8);
-    s2[(1_usize) as usize] = ('b' as u8);
-    s2[(2_usize) as usize] = ('b' as u8);
-    assert!(((s2[(0_usize) as usize] as i32) == (('b' as u8) as i32)));
-    assert!(((s2[(1_usize) as usize] as i32) == (('b' as u8) as i32)));
-    assert!(((s2[(2_usize) as usize] as i32) == (('b' as u8) as i32)));
-    assert!(((s1[(0_usize) as usize] as i32) == (('a' as u8) as i32)));
-    assert!(((s1[(1_usize) as usize] as i32) == (('a' as u8) as i32)));
-    assert!(((s1[(2_usize) as usize] as i32) == (('a' as u8) as i32)));
+    s2[(0_usize)] = ('b' as u8);
+    s2[(1_usize)] = ('b' as u8);
+    s2[(2_usize)] = ('b' as u8);
+    assert!(((s2[(0_usize)] as i32) == (('b' as u8) as i32)));
+    assert!(((s2[(1_usize)] as i32) == (('b' as u8) as i32)));
+    assert!(((s2[(2_usize)] as i32) == (('b' as u8) as i32)));
+    assert!(((s1[(0_usize)] as i32) == (('a' as u8) as i32)));
+    assert!(((s1[(1_usize)] as i32) == (('a' as u8) as i32)));
+    assert!(((s1[(2_usize)] as i32) == (('a' as u8) as i32)));
     let mut b1: Bar = Bar { w: 1 };
     let mut b2: Bar = Bar { w: 2 };
     b2 = b1;
@@ -235,14 +235,14 @@ unsafe fn main_0() -> i32 {
     v4 = v2.clone();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((v4[(i as usize) as usize]) == ((i) + (1))));
-        v4[(i as usize) as usize].prefix_inc();
+        assert!(((v4[(i as usize)]) == ((i) + (1))));
+        v4[(i as usize)].prefix_inc();
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((v4[(i as usize) as usize]) == ((i) + (2))));
-        assert!(((v2[(i as usize) as usize]) == ((i) + (1))));
+        assert!(((v4[(i as usize)]) == ((i) + (2))));
+        assert!(((v2[(i as usize)]) == ((i) + (1))));
         i.prefix_inc();
     }
     return 0;

tests/unit/out/unsafe/fft.rs

@@ -40,9 +40,9 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
             .collect::<Box<[_]>>(),
     );
     if ((N) == (1)) {
-        y.as_mut().unwrap()[(0_usize) as usize] = Complex {
-            re: (*a).as_mut().unwrap()[(0_usize) as usize].re,
-            img: (*a).as_mut().unwrap()[(0_usize) as usize].img,
+        y.as_mut().unwrap()[(0_usize)] = Complex {
+            re: (*a).as_mut().unwrap()[(0_usize)].re,
+            img: (*a).as_mut().unwrap()[(0_usize)].img,
         };
         return y;
     }
@@ -54,7 +54,7 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         let mut alpha: f64 = ((((-2_i32 as f64) * (3.141592654E+0)) * (i as f64)) / (N as f64));
-        w.as_mut().unwrap()[(i as usize) as usize] = Complex {
+        w.as_mut().unwrap()[(i as usize)] = Complex {
             re: alpha.cos(),
             img: alpha.sin(),
         };
@@ -72,13 +72,13 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < ((N) / (2))) {
-        A0.as_mut().unwrap()[(i as usize) as usize] = Complex {
-            re: (*a).as_mut().unwrap()[(((i) * (2)) as usize) as usize].re,
-            img: (*a).as_mut().unwrap()[(((i) * (2)) as usize) as usize].img,
+        A0.as_mut().unwrap()[(i as usize)] = Complex {
+            re: (*a).as_mut().unwrap()[(((i) * (2)) as usize)].re,
+            img: (*a).as_mut().unwrap()[(((i) * (2)) as usize)].img,
         };
-        A1.as_mut().unwrap()[(i as usize) as usize] = Complex {
-            re: (*a).as_mut().unwrap()[((((i) * (2)) + (1)) as usize) as usize].re,
-            img: (*a).as_mut().unwrap()[((((i) * (2)) + (1)) as usize) as usize].img,
+        A1.as_mut().unwrap()[(i as usize)] = Complex {
+            re: (*a).as_mut().unwrap()[((((i) * (2)) + (1)) as usize)].re,
+            img: (*a).as_mut().unwrap()[((((i) * (2)) + (1)) as usize)].img,
         };
         i.postfix_inc();
     }
@@ -95,31 +95,31 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
     let mut k: i32 = 0;
     'loop_: while ((k) < ((N) / (2))) {
         let mut yk: Complex = (unsafe {
-            let _z1: Complex = y0.as_mut().unwrap()[(k as usize) as usize].clone();
+            let _z1: Complex = y0.as_mut().unwrap()[(k as usize)].clone();
             let _z2: Complex = (unsafe {
-                let _z1: Complex = w.as_mut().unwrap()[(k as usize) as usize].clone();
-                let _z2: Complex = y1.as_mut().unwrap()[(k as usize) as usize].clone();
+                let _z1: Complex = w.as_mut().unwrap()[(k as usize)].clone();
+                let _z2: Complex = y1.as_mut().unwrap()[(k as usize)].clone();
                 Product_0(_z1, _z2)
             });
             Sum_1(_z1, _z2)
         });
-        y.as_mut().unwrap()[(k as usize) as usize] = Complex {
+        y.as_mut().unwrap()[(k as usize)] = Complex {
             re: yk.re,
             img: yk.img,
         };
         let mut yk_n2: Complex = (unsafe {
-            let _z1: Complex = y0.as_mut().unwrap()[(k as usize) as usize].clone();
+            let _z1: Complex = y0.as_mut().unwrap()[(k as usize)].clone();
             let _z2: Complex = (unsafe {
                 let _z1: Complex = (unsafe {
-                    let _z1: Complex = w.as_mut().unwrap()[(k as usize) as usize].clone();
-                    let _z2: Complex = y1.as_mut().unwrap()[(k as usize) as usize].clone();
+                    let _z1: Complex = w.as_mut().unwrap()[(k as usize)].clone();
+                    let _z2: Complex = y1.as_mut().unwrap()[(k as usize)].clone();
                     Product_0(_z1, _z2)
                 });
                 Neg_2(_z1)
             });
             Sum_1(_z1, _z2)
         });
-        y.as_mut().unwrap()[(((k) + ((N) / (2))) as usize) as usize] = Complex {
+        y.as_mut().unwrap()[(((k) + ((N) / (2))) as usize)] = Complex {
             re: yk_n2.re,
             img: yk_n2.img,
         };
@@ -141,7 +141,7 @@ unsafe fn main_0() -> i32 {
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        a.as_mut().unwrap()[(i as usize) as usize] = Complex {
+        a.as_mut().unwrap()[(i as usize)] = Complex {
             re: ((i as f64) + (1_f64)),
             img: 0_f64,
         };
@@ -164,18 +164,18 @@ unsafe fn main_0() -> i32 {
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        reals.as_mut().unwrap()[(i as usize) as usize] =
-            (b.as_mut().unwrap()[(i as usize) as usize].re.round() as i32);
-        imgs.as_mut().unwrap()[(i as usize) as usize] =
-            (b.as_mut().unwrap()[(i as usize) as usize].img.round() as i32);
+        reals.as_mut().unwrap()[(i as usize)] =
+            (b.as_mut().unwrap()[(i as usize)].re.round() as i32);
+        imgs.as_mut().unwrap()[(i as usize)] =
+            (b.as_mut().unwrap()[(i as usize)].img.round() as i32);
         i.prefix_inc();
     }
-    return (((((((reals.as_mut().unwrap()[(0_usize) as usize]) == (10))
-        && ((imgs.as_mut().unwrap()[(0_usize) as usize]) == (0)))
-        && (((reals.as_mut().unwrap()[(1_usize) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(1_usize) as usize]) == (2))))
-        && (((reals.as_mut().unwrap()[(2_usize) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(2_usize) as usize]) == (0))))
-        && (((reals.as_mut().unwrap()[(3_usize) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(3_usize) as usize]) == (-2_i32)))) as i32);
+    return (((((((reals.as_mut().unwrap()[(0_usize)]) == (10))
+        && ((imgs.as_mut().unwrap()[(0_usize)]) == (0)))
+        && (((reals.as_mut().unwrap()[(1_usize)]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(1_usize)]) == (2))))
+        && (((reals.as_mut().unwrap()[(2_usize)]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(2_usize)]) == (0))))
+        && (((reals.as_mut().unwrap()[(3_usize)]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(3_usize)]) == (-2_i32)))) as i32);
 }

tests/unit/out/unsafe/fn_ptr_stable_sort.rs

@@ -37,8 +37,8 @@ unsafe fn main_0() -> i32 {
             }
         })
     };
-    assert!(((v[(0_usize) as usize].key) == (1)));
-    assert!(((v[(1_usize) as usize].key) == (2)));
-    assert!(((v[(2_usize) as usize].key) == (3)));
+    assert!(((v[(0_usize)].key) == (1)));
+    assert!(((v[(1_usize)].key) == (2)));
+    assert!(((v[(2_usize)].key) == (3)));
     return 0;
 }

tests/unit/out/unsafe/foreach_mut.rs

@@ -34,9 +34,9 @@ unsafe fn main_0() -> i32 {
         sum += (*x);
     }
     let mut v2: Vec<*mut i32> = Vec::new();
-    v2.push((&mut v1[(0_usize) as usize] as *mut i32));
-    v2.push((&mut v1[(1_usize) as usize] as *mut i32));
-    v2.push((&mut v1[(2_usize) as usize] as *mut i32));
+    v2.push((&mut v1[(0_usize)] as *mut i32));
+    v2.push((&mut v1[(1_usize)] as *mut i32));
+    v2.push((&mut v1[(2_usize)] as *mut i32));
     'loop_: for p in 0..(v2.len()) {
         let mut p = v2[p].clone();
         (*p) += 5;