Drop suffix from integer literals

cpp2rust/converter/converter.cpp

@@ -1643,7 +1643,7 @@ bool Converter::VisitIntegerLiteral(clang::IntegerLiteral *expr) {
     computed_expr_type_ = ComputedExprType::FreshValue;
     return false;
   }
-  StrCat(getIntegerLiteral(expr, Mapper::Map(expr->getType()) != "i32"));
+  StrCat(getIntegerLiteral(expr, false));
   computed_expr_type_ = ComputedExprType::FreshValue;
   return false;
 }

tests/benchmarks/out/refcount/sum.rs

@@ -10,7 +10,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let N: Value<i64> = Rc::new(RefCell::new(25000000000_i64));
+    let N: Value<i64> = Rc::new(RefCell::new(25000000000));
     let sum: Value<i64> = Rc::new(RefCell::new(0_i64));
     let i: Value<i64> = Rc::new(RefCell::new(0_i64));
     let j: Value<i64> = Rc::new(RefCell::new((*N.borrow())));

tests/benchmarks/out/unsafe/sum.rs

@@ -12,7 +12,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut N: i64 = 25000000000_i64;
+    let mut N: i64 = 25000000000;
     let mut sum: i64 = 0_i64;
     let mut i: i64 = 0_i64;
     let mut j: i64 = N;

tests/unit/out/refcount/bool_condition_logical.rs

@@ -86,44 +86,44 @@ fn main_0() -> i32 {
     assert!(((*side_effect.with(Value::clone).borrow()) == 0));
     let x: Value<i32> = Rc::new(RefCell::new(5));
     let y: Value<i32> = Rc::new(RefCell::new(3));
-    let flags: Value<u32> = Rc::new(RefCell::new(2_u32));
-    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0) {
+    let flags: Value<u32> = Rc::new(RefCell::new(2));
+    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 1) != 0) {
         assert!(true);
     }
-    if ((*x.borrow()) < (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0) {
+    if ((*x.borrow()) < (*y.borrow())) || (((*flags.borrow()) & 1) != 0) {
         assert!(false);
     }
-    let a: Value<u32> = Rc::new(RefCell::new(1_u32));
-    let b: Value<u32> = Rc::new(RefCell::new(2_u32));
-    let c: Value<u32> = Rc::new(RefCell::new(3_u32));
+    let a: Value<u32> = Rc::new(RefCell::new(1));
+    let b: Value<u32> = Rc::new(RefCell::new(2));
+    let c: Value<u32> = Rc::new(RefCell::new(3));
     if ((*a.borrow()) != (*c.borrow())) && ((*b.borrow()) != (*c.borrow())) {
         assert!(true);
     }
     let s: Value<i32> = Rc::new(RefCell::new(-1_i32));
     if (!((*p.borrow()).is_null())) && ((*s.borrow()) < 0) {
         assert!(true);
     }
-    let k: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let k: Value<u32> = Rc::new(RefCell::new(2));
     let done: Value<bool> = Rc::new(RefCell::new(false));
-    if ((*k.borrow()) > 1_u32) || (!(*done.borrow())) {
+    if ((*k.borrow()) > 1) || (!(*done.borrow())) {
         assert!(true);
     }
-    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 4_u32) != 0) {
+    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 4) != 0) {
         assert!(true);
     }
-    let ull: Value<u64> = Rc::new(RefCell::new(7_u64));
+    let ull: Value<u64> = Rc::new(RefCell::new(7));
     if (!((*p.borrow()).is_null())) && ((*ull.borrow()) != 0) {
         assert!(true);
     }
     if ((*x.borrow()) > (*y.borrow())) && ((*ull.borrow()) != 0) {
         assert!(true);
     }
-    let mask: Value<i64> = Rc::new(RefCell::new(((1_i64 << 4) | (1_i64 << 5))));
-    let bits: Value<i64> = Rc::new(RefCell::new((1_i64 << 4)));
+    let mask: Value<i64> = Rc::new(RefCell::new(((1 << 4) | (1 << 5))));
+    let bits: Value<i64> = Rc::new(RefCell::new((1 << 4)));
     if ((*n.borrow()) != 0) && (((*bits.borrow()) & (*mask.borrow())) != 0) {
         assert!(true);
     }
-    if ((*n.borrow()) != 0) || (((*bits.borrow()) & 256_i64) != 0) {
+    if ((*n.borrow()) != 0) || (((*bits.borrow()) & 256) != 0) {
         assert!(true);
     }
     let cp: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hi")));

tests/unit/out/refcount/bool_condition_logical_c.rs

@@ -92,22 +92,22 @@ fn main_0() -> i32 {
     assert!(((((*side_effect.with(Value::clone).borrow()) == 0) as i32) != 0));
     let x: Value<i32> = Rc::new(RefCell::new(5));
     let y: Value<i32> = Rc::new(RefCell::new(3));
-    let flags: Value<u32> = Rc::new(RefCell::new(2_u32));
-    if (((((((*x.borrow()) > (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 1_u32) != 0))
+    let flags: Value<u32> = Rc::new(RefCell::new(2));
+    if (((((((*x.borrow()) > (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 1) != 0))
         as i32)
         != 0)
     {
         assert!((1 != 0));
     }
-    if (((((((*x.borrow()) < (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 1_u32) != 0))
+    if (((((((*x.borrow()) < (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 1) != 0))
         as i32)
         != 0)
     {
         assert!((0 != 0));
     }
-    let a: Value<u32> = Rc::new(RefCell::new(1_u32));
-    let b: Value<u32> = Rc::new(RefCell::new(2_u32));
-    let c: Value<u32> = Rc::new(RefCell::new(3_u32));
+    let a: Value<u32> = Rc::new(RefCell::new(1));
+    let b: Value<u32> = Rc::new(RefCell::new(2));
+    let c: Value<u32> = Rc::new(RefCell::new(3));
     if (((((((*a.borrow()) != (*c.borrow())) as i32) != 0)
         && ((((*b.borrow()) != (*c.borrow())) as i32) != 0)) as i32)
         != 0)
@@ -121,34 +121,33 @@ fn main_0() -> i32 {
     {
         assert!((1 != 0));
     }
-    let k: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let k: Value<u32> = Rc::new(RefCell::new(2));
     let done: Value<bool> = Rc::new(RefCell::new((0 != 0)));
-    if (((((((*k.borrow()) > 1_u32) as i32) != 0) || (!(*done.borrow()))) as i32) != 0) {
+    if (((((((*k.borrow()) > 1) as i32) != 0) || (!(*done.borrow()))) as i32) != 0) {
         assert!((1 != 0));
     }
-    if (((((((*x.borrow()) > (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 4_u32) != 0))
+    if (((((((*x.borrow()) > (*y.borrow())) as i32) != 0) || (((*flags.borrow()) & 4) != 0))
         as i32)
         != 0)
     {
         assert!((1 != 0));
     }
-    let ull: Value<u64> = Rc::new(RefCell::new(7_u64));
+    let ull: Value<u64> = Rc::new(RefCell::new(7));
     if ((((((!((*p.borrow()).is_null())) as i32) != 0) && ((*ull.borrow()) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
     if (((((((*x.borrow()) > (*y.borrow())) as i32) != 0) && ((*ull.borrow()) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
-    let mask: Value<i64> = Rc::new(RefCell::new(((1_i64 << 4) | (1_i64 << 5))));
-    let bits: Value<i64> = Rc::new(RefCell::new((1_i64 << 4)));
+    let mask: Value<i64> = Rc::new(RefCell::new(((1 << 4) | (1 << 5))));
+    let bits: Value<i64> = Rc::new(RefCell::new((1 << 4)));
     if (((((((*n.borrow()) != 0) as i32) != 0) && (((*bits.borrow()) & (*mask.borrow())) != 0))
         as i32)
         != 0)
     {
         assert!((1 != 0));
     }
-    if (((((((*n.borrow()) != 0) as i32) != 0) || (((*bits.borrow()) & 256_i64) != 0)) as i32) != 0)
-    {
+    if (((((((*n.borrow()) != 0) as i32) != 0) || (((*bits.borrow()) & 256) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
     let cp: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hi")));

tests/unit/out/refcount/int_to_bool_explicit.rs

@@ -12,7 +12,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let flag: Value<u32> = Rc::new(RefCell::new(7_u32));
     let b1: Value<bool> = Rc::new(RefCell::new(((*flag.borrow()) != 0)));
-    let b2: Value<bool> = Rc::new(RefCell::new((0_u32 != 0)));
+    let b2: Value<bool> = Rc::new(RefCell::new((0 != 0)));
     assert!((*b1.borrow()));
     assert!(!(*b2.borrow()));
     return 0;

tests/unit/out/refcount/int_to_bool_explicit_c.rs

@@ -12,7 +12,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let flag: Value<u32> = Rc::new(RefCell::new(7_u32));
     let b1: Value<bool> = Rc::new(RefCell::new(((*flag.borrow()) != 0)));
-    let b2: Value<bool> = Rc::new(RefCell::new((0_u32 != 0)));
+    let b2: Value<bool> = Rc::new(RefCell::new((0 != 0)));
     assert!((*b1.borrow()));
     assert!(((!(*b2.borrow()) as i32) != 0));
     return 0;

tests/unit/out/refcount/printfs.rs

@@ -24,7 +24,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     println!("{}", Ptr::from_string_literal("fprintf stdout"));
-    println!("{} {} {}", 1, 2_u32, 3_i64);
+    println!("{} {} {}", 1, 2, 3);
     print!("hello world");
     println!("{}", Ptr::from_string_literal("printf"));
     print!("hello world");

tests/unit/out/refcount/reinterpret_cast_aliased.rs

@@ -15,11 +15,11 @@ fn main_0() -> i32 {
         Rc::new(RefCell::new((val.as_pointer()).reinterpret_cast::<u32>()));
     let view2: Value<Ptr<u32>> =
         Rc::new(RefCell::new((val.as_pointer()).reinterpret_cast::<u32>()));
-    (*view1.borrow()).offset((0) as isize).write(3721182122_u32);
-    assert!((((*view2.borrow()).offset((0) as isize).read()) == 3721182122_u32));
-    assert!(((*val.borrow()) == 578437699406183338_u64));
-    (*view2.borrow()).offset((1) as isize).write(4293844428_u32);
-    assert!((((*view1.borrow()).offset((1) as isize).read()) == 4293844428_u32));
-    assert!(((*val.borrow()) == 18441921396093008810_u64));
+    (*view1.borrow()).offset((0) as isize).write(3721182122);
+    assert!((((*view2.borrow()).offset((0) as isize).read()) == 3721182122));
+    assert!(((*val.borrow()) == 578437699406183338));
+    (*view2.borrow()).offset((1) as isize).write(4293844428);
+    assert!((((*view1.borrow()).offset((1) as isize).read()) == 4293844428));
+    assert!(((*val.borrow()) == 18441921396093008810));
     return 0;
 }

tests/unit/out/refcount/reinterpret_cast_chain.rs

@@ -23,12 +23,10 @@ fn main_0() -> i32 {
     assert!(((((*words.borrow()).offset((2) as isize).read()) as i32) == 1541));
     assert!(((((*words.borrow()).offset((3) as isize).read()) as i32) == 2055));
     (*words.borrow()).offset((1) as isize).write(48042_u16);
-    assert!((((*dwords.borrow()).offset((0) as isize).read()) == 3148481025_u32));
-    assert!(((*val.borrow()) == 578437698833482241_u64));
-    (*dwords.borrow())
-        .offset((1) as isize)
-        .write(4293844428_u32);
-    assert!(((*val.borrow()) == 18441921395520307713_u64));
+    assert!((((*dwords.borrow()).offset((0) as isize).read()) == 3148481025));
+    assert!(((*val.borrow()) == 578437698833482241));
+    (*dwords.borrow()).offset((1) as isize).write(4293844428);
+    assert!(((*val.borrow()) == 18441921395520307713));
     assert!(((((*words.borrow()).offset((2) as isize).read()) as i32) == 56780));
     assert!(((((*words.borrow()).offset((3) as isize).read()) as i32) == 65518));
     return 0;

tests/unit/out/refcount/reinterpret_cast_double.rs

@@ -12,7 +12,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let d: Value<f64> = Rc::new(RefCell::new(1.0E+0));
     let bits: Value<Ptr<u64>> = Rc::new(RefCell::new((d.as_pointer()).reinterpret_cast::<u64>()));
-    assert!((((*bits.borrow()).read()) == 4607182418800017408_u64));
+    assert!((((*bits.borrow()).read()) == 4607182418800017408));
     (*bits.borrow()).write(4614256656552045848_u64);
     assert!(((*d.borrow()) > 3.14E+0) && ((*d.borrow()) < 3.15E+0));
     return 0;

tests/unit/out/refcount/reinterpret_cast_large_array.rs

@@ -23,7 +23,7 @@ fn main_0() -> i32 {
     }
     (*arr.borrow())
         .offset(((*N.borrow()) - 1) as isize)
-        .write(3148519816_u32);
+        .write(3148519816);
     let words: Value<Ptr<u16>> = Rc::new(RefCell::new(
         ((*arr.borrow()).reinterpret_cast::<u16>()).clone(),
     ));

tests/unit/out/refcount/reinterpret_cast_partial_overlap.rs

@@ -17,7 +17,7 @@ fn main_0() -> i32 {
     assert!(((((*bytes.borrow()).offset((3) as isize).read()) as i32) == 4));
     assert!(((((*bytes.borrow()).offset((4) as isize).read()) as i32) == 5));
     (*bytes.borrow()).offset((3) as isize).write(255_u8);
-    assert!(((*arr.borrow())[(0) as usize] == 4278387201_u32));
+    assert!(((*arr.borrow())[(0) as usize] == 4278387201));
     (*bytes.borrow()).offset((4) as isize).write(170_u8);
     assert!(((*arr.borrow())[(1) as usize] == 134678186_u32));
     return 0;

tests/unit/out/refcount/reinterpret_cast_u32_from_u8.rs

@@ -17,6 +17,6 @@ fn main_0() -> i32 {
         (arr.as_pointer() as Ptr<u8>).reinterpret_cast::<u32>(),
     ));
     assert!((((*dwords.borrow()).offset((0) as isize).read()) == 305419896_u32));
-    assert!((((*dwords.borrow()).offset((1) as isize).read()) == 2427178479_u32));
+    assert!((((*dwords.borrow()).offset((1) as isize).read()) == 2427178479));
     return 0;
 }

tests/unit/out/refcount/reinterpret_cast_zero_init.rs

@@ -16,6 +16,6 @@ fn main_0() -> i32 {
     (*bytes.borrow()).offset((1) as isize).write(190_u8);
     (*bytes.borrow()).offset((2) as isize).write(173_u8);
     (*bytes.borrow()).offset((3) as isize).write(222_u8);
-    assert!(((*val.borrow()) == 3735928559_u32));
+    assert!(((*val.borrow()) == 3735928559));
     return 0;
 }

tests/unit/out/refcount/types.rs

@@ -20,7 +20,7 @@ fn main_0() -> i32 {
     let xi2: Value<i16> = Rc::new(RefCell::new(16_i16));
     let xi3: Value<i32> = Rc::new(RefCell::new(32));
     let xi4: Value<i64> = Rc::new(RefCell::new(64_i64));
-    let b: Value<bool> = Rc::new(RefCell::new(((*xu64.borrow()) == 64_u64)));
+    let b: Value<bool> = Rc::new(RefCell::new(((*xu64.borrow()) == 64)));
     return ((((((((((((((*xu8.borrow()) as i32) + ((*xu16.borrow()) as i32)) as u32)
         .wrapping_add((*xu32.borrow()))) as u64)
         .wrapping_add((*xu64.borrow())))

tests/unit/out/refcount/va_arg_mixed_types.rs

@@ -41,7 +41,7 @@ fn main_0() -> i32 {
                     1.into(),
                     2.05E+1.into(),
                     2.into(),
-                    30_i64.into(),
+                    30.into(),
                 ],
             )
         }) == 60) as i32)
@@ -57,7 +57,7 @@ fn main_0() -> i32 {
     assert!(
         (((({
             let _count: i32 = 2;
-            sum_mixed_0(_count, &[1.into(), 3.7E+0.into(), 2.into(), 100_i64.into()])
+            sum_mixed_0(_count, &[1.into(), 3.7E+0.into(), 2.into(), 100.into()])
         }) == 103) as i32)
             != 0)
     );

tests/unit/out/unsafe/bool_condition_logical.rs

@@ -83,44 +83,44 @@ unsafe fn main_0() -> i32 {
     assert!(((side_effect) == (0)));
     let mut x: i32 = 5;
     let mut y: i32 = 3;
-    let mut flags: u32 = 2_u32;
-    if ((x) > (y)) || (((flags) & (1_u32)) != 0) {
+    let mut flags: u32 = 2;
+    if ((x) > (y)) || (((flags) & (1)) != 0) {
         assert!(true);
     }
-    if ((x) < (y)) || (((flags) & (1_u32)) != 0) {
+    if ((x) < (y)) || (((flags) & (1)) != 0) {
         assert!(false);
     }
-    let mut a: u32 = 1_u32;
-    let mut b: u32 = 2_u32;
-    let mut c: u32 = 3_u32;
+    let mut a: u32 = 1;
+    let mut b: u32 = 2;
+    let mut c: u32 = 3;
     if ((a) != (c)) && ((b) != (c)) {
         assert!(true);
     }
     let mut s: i32 = -1_i32;
     if (!((p).is_null())) && ((s) < (0)) {
         assert!(true);
     }
-    let mut k: u32 = 2_u32;
+    let mut k: u32 = 2;
     let mut done: bool = false;
-    if ((k) > (1_u32)) || (!done) {
+    if ((k) > (1)) || (!done) {
         assert!(true);
     }
-    if ((x) > (y)) || (((flags) & (4_u32)) != 0) {
+    if ((x) > (y)) || (((flags) & (4)) != 0) {
         assert!(true);
     }
-    let mut ull: u64 = 7_u64;
+    let mut ull: u64 = 7;
     if (!((p).is_null())) && (ull != 0) {
         assert!(true);
     }
     if ((x) > (y)) && (ull != 0) {
         assert!(true);
     }
-    let mut mask: i64 = (((1_i64) << (4)) | ((1_i64) << (5)));
-    let mut bits: i64 = ((1_i64) << (4));
+    let mut mask: i64 = (((1) << (4)) | ((1) << (5)));
+    let mut bits: i64 = ((1) << (4));
     if ((n) != (0)) && (((bits) & (mask)) != 0) {
         assert!(true);
     }
-    if ((n) != (0)) || (((bits) & (256_i64)) != 0) {
+    if ((n) != (0)) || (((bits) & (256)) != 0) {
         assert!(true);
     }
     let mut cp: *const u8 = b"hi\0".as_ptr();