Update tests

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -2089,13 +2089,9 @@ std::string ConverterRefCount::ConvertVarInitValue(clang::QualType qual_type,
     Buffer buf(*this);
     PushConversionKind push(*this, ConversionKind::Unboxed);
     if (qual_type->isFunctionPointerType() && lambda->capture_size() == 0) {
-      auto proto = lambda->getCallOperator()
-                       ->getType()
-                       ->getAs<clang::FunctionProtoType>();
-      StrCat(
-          std::format("FnPtr::<{}>::new", ConvertFunctionPointerType(proto)));
-      PushParen paren(*this);
+      StrCat("FnPtr::new(");
       VisitLambdaExpr(lambda);
+      StrCat(')');
     } else {
       VisitLambdaExpr(lambda);
     }

tests/unit/out/refcount/fn_ptr_default_arg.rs

@@ -26,7 +26,7 @@ fn main_0() -> i32 {
     assert!((({ apply_1(5, None,) }) == 5));
     assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::null()),) }) == 5));
     assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::new(identity_0)),) }) == 5));
-    let negate: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
+    let negate: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::new(
         (|x: i32| {
             let x: Value<i32> = Rc::new(RefCell::new(x));
             return -(*x.borrow());

tests/unit/out/refcount/fn_ptr_stable_sort.rs

@@ -61,7 +61,7 @@ fn main_0() -> i32 {
     });
     (v.as_pointer() as Ptr<Item>).sort_with_cmp(
         (v.as_pointer() as Ptr<Item>).to_end().get_offset(),
-        |x, y| FnPtr::<fn(Ptr<Item>, Ptr<Item>) -> bool>::new(Compare_0).call(x, y),
+        |x, y| Compare_0.call(x, y),
     );
     assert!(
         ((*(*(v.as_pointer() as Ptr<Item>)

tests/unit/out/refcount/qsort_bsearch.rs

@@ -29,7 +29,7 @@ fn main_0() -> i32 {
         for __i in 0..8_usize {
             let mut __min = __i;
             for __j in (__i + 1)..8_usize {
-                if FnPtr::<fn(AnyPtr, AnyPtr) -> i32>::new(cmp_int_0).call(
+                if cmp_int_0(
                     __base.offset(__j * ::std::mem::size_of::<i32>()).to_any(),
                     __base.offset(__min * ::std::mem::size_of::<i32>()).to_any(),
                 ) < 0
@@ -76,7 +76,7 @@ fn main_0() -> i32 {
             while __lo <= __hi && __found.is_null() {
                 let __mid = __lo + (__hi - __lo) / 2;
                 let __elem = __base.offset(__mid as usize * ::std::mem::size_of::<i32>());
-                let __r = FnPtr::<fn(AnyPtr, AnyPtr) -> i32>::new(cmp_int_0).call(
+                let __r = cmp_int_0(
                     ((key.as_pointer()) as Ptr<i32>).to_any().clone(),
                     __elem.to_any(),
                 );
@@ -106,7 +106,7 @@ fn main_0() -> i32 {
             while __lo <= __hi && __found.is_null() {
                 let __mid = __lo + (__hi - __lo) / 2;
                 let __elem = __base.offset(__mid as usize * ::std::mem::size_of::<i32>());
-                let __r = FnPtr::<fn(AnyPtr, AnyPtr) -> i32>::new(cmp_int_0).call(
+                let __r = cmp_int_0(
                     ((miss_key.as_pointer()) as Ptr<i32>).to_any().clone(),
                     __elem.to_any(),
                 );

tests/unit/out/unsafe/fn_ptr.rs

@@ -23,10 +23,10 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut fn_: Option<unsafe fn(*mut ::libc::c_void) -> i32> = None;
     assert!((fn_).is_none());
-    assert!(((fn_) != (Some(my_foo_0 as unsafe fn(*mut ::libc::c_void) -> i32))));
-    fn_ = Some(my_foo_0 as unsafe fn(*mut ::libc::c_void) -> i32);
+    assert!(((fn_) != (Some(my_foo_0))));
+    fn_ = Some(my_foo_0);
     assert!(!((fn_).is_none()));
-    assert!(((fn_) == (Some(my_foo_0 as unsafe fn(*mut ::libc::c_void) -> i32))));
+    assert!(((fn_) == (Some(my_foo_0))));
     let mut a: i32 = 10;
     assert!(((unsafe { foo_1(fn_, (&mut a as *mut i32),) }) == (a)));
     return 0;

tests/unit/out/unsafe/fn_ptr_arity.rs

@@ -32,25 +32,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut f: Option<
         unsafe fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) -> i32,
-    > = (Some(
-        foo_0
-            as unsafe fn(
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-                i32,
-            ) -> i32,
-    ));
+    > = (Some(foo_0));
     assert!(((unsafe { (f).unwrap()(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,) }) == (22)));
     return 0;
 }

tests/unit/out/unsafe/fn_ptr_array.rs

@@ -21,16 +21,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut ops: [Option<unsafe fn(i32, i32) -> i32>; 3] = [
-        Some(add_0 as unsafe fn(i32, i32) -> i32),
-        Some(sub_1 as unsafe fn(i32, i32) -> i32),
-        Some(mul_2 as unsafe fn(i32, i32) -> i32),
-    ];
+    let mut ops: [Option<unsafe fn(i32, i32) -> i32>; 3] = [Some(add_0), Some(sub_1), Some(mul_2)];
     assert!(((unsafe { (ops[(0) as usize]).unwrap()(2, 3,) }) == (5)));
     assert!(((unsafe { (ops[(1) as usize]).unwrap()(7, 4,) }) == (3)));
     assert!(((unsafe { (ops[(2) as usize]).unwrap()(6, 5,) }) == (30)));
     assert!(!((ops[(0) as usize]).is_none()));
-    assert!(((ops[(0) as usize]) == (Some(add_0 as unsafe fn(i32, i32) -> i32))));
-    assert!(((ops[(0) as usize]) != (Some(sub_1 as unsafe fn(i32, i32) -> i32))));
+    assert!(((ops[(0) as usize]) == (Some(add_0))));
+    assert!(((ops[(0) as usize]) != (Some(sub_1))));
     return 0;
 }

tests/unit/out/unsafe/fn_ptr_as_condition.rs

@@ -21,19 +21,14 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: i32 = 5;
-    (unsafe {
-        maybe_call_1(
-            Some(double_it_0 as unsafe fn(*mut i32)),
-            (&mut a as *mut i32),
-        )
-    });
+    (unsafe { maybe_call_1(Some(double_it_0), (&mut a as *mut i32)) });
     assert!(((a) == (10)));
     let mut b: i32 = 5;
     (unsafe { maybe_call_1(None, (&mut b as *mut i32)) });
     assert!(((b) == (5)));
     let mut fn_: Option<unsafe fn(*mut i32)> = None;
     if !(!(fn_).is_none()) {
-        fn_ = Some(double_it_0 as unsafe fn(*mut i32));
+        fn_ = Some(double_it_0);
     }
     let mut c: i32 = 3;
     if !(fn_).is_none() {

tests/unit/out/unsafe/fn_ptr_cast.rs

@@ -10,7 +10,7 @@ pub unsafe fn double_it_0(mut x: i32) -> i32 {
     return ((x) * (2));
 }
 pub unsafe fn test_roundtrip_1() {
-    let mut fn_: Option<unsafe fn(i32) -> i32> = Some(double_it_0 as unsafe fn(i32) -> i32);
+    let mut fn_: Option<unsafe fn(i32) -> i32> = Some(double_it_0);
     assert!(((unsafe { (fn_).unwrap()(5,) }) == (10)));
     let mut gfn: Option<unsafe fn()> =
         std::mem::transmute::<Option<unsafe fn(i32) -> i32>, Option<unsafe fn()>>(fn_);
@@ -21,7 +21,7 @@ pub unsafe fn test_roundtrip_1() {
     assert!(((fn2) == (fn_)));
 }
 pub unsafe fn test_double_cast_2() {
-    let mut fn_: Option<unsafe fn(i32) -> i32> = Some(double_it_0 as unsafe fn(i32) -> i32);
+    let mut fn_: Option<unsafe fn(i32) -> i32> = Some(double_it_0);
     let mut fn2: Option<unsafe fn(i32) -> i32> =
         std::mem::transmute::<Option<unsafe fn()>, Option<unsafe fn(i32) -> i32>>(
             std::mem::transmute::<Option<unsafe fn(i32) -> i32>, Option<unsafe fn()>>(fn_),
@@ -37,7 +37,7 @@ pub struct Command {
 pub unsafe fn test_void_ptr_to_fn_3() {
     let mut cmd: Command = <Command>::default();
     cmd.data = std::mem::transmute::<Option<unsafe fn(i32) -> i32>, *mut ::libc::c_void>(Some(
-        double_it_0 as unsafe fn(i32) -> i32,
+        double_it_0,
     ));
     let mut fn_: Option<unsafe fn(i32) -> i32> =
         std::mem::transmute::<*mut ::libc::c_void, Option<unsafe fn(i32) -> i32>>(cmd.data);
@@ -47,11 +47,10 @@ pub unsafe fn add_offset_4(mut base: *mut i32, mut offset: i32) -> i32 {
     return ((*base) + (offset));
 }
 pub unsafe fn test_call_through_cast_5() {
-    let mut gfn: Option<unsafe fn(*mut ::libc::c_void, i32) -> i32> =
-        std::mem::transmute::<
-            Option<unsafe fn(*mut i32, i32) -> i32>,
-            Option<unsafe fn(*mut ::libc::c_void, i32) -> i32>,
-        >(Some(add_offset_4 as unsafe fn(*mut i32, i32) -> i32));
+    let mut gfn: Option<unsafe fn(*mut ::libc::c_void, i32) -> i32> = std::mem::transmute::<
+        Option<unsafe fn(*mut i32, i32) -> i32>,
+        Option<unsafe fn(*mut ::libc::c_void, i32) -> i32>,
+    >(Some(add_offset_4));
     let mut val: i32 = 100;
     let mut result: i32 = (unsafe {
         (gfn).unwrap()(

tests/unit/out/unsafe/fn_ptr_conditional.rs

@@ -17,20 +17,20 @@ pub unsafe fn identity_2(mut x: i32) -> i32 {
 }
 pub unsafe fn pick_3(mut mode: i32) -> Option<unsafe fn(i32) -> i32> {
     return if ((mode) > (0)) {
-        Some(inc_0 as unsafe fn(i32) -> i32)
+        Some(inc_0)
     } else {
         if ((mode) < (0)) {
-            Some(dec_1 as unsafe fn(i32) -> i32)
+            Some(dec_1)
         } else {
-            Some(identity_2 as unsafe fn(i32) -> i32)
+            Some(identity_2)
         }
     };
 }
 pub unsafe fn apply_4(mut fn_: Option<unsafe fn(i32) -> i32>, mut x: i32) -> i32 {
     let mut actual: Option<unsafe fn(i32) -> i32> = if !(fn_).is_none() {
         fn_
     } else {
-        Some(identity_2 as unsafe fn(i32) -> i32)
+        Some(identity_2)
     };
     return (unsafe { (actual).unwrap()(x) });
 }
@@ -43,7 +43,7 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { (unsafe { pick_3(1,) }).unwrap()(10,) }) == (11)));
     assert!(((unsafe { (unsafe { pick_3(-1_i32,) }).unwrap()(10,) }) == (9)));
     assert!(((unsafe { (unsafe { pick_3(0,) }).unwrap()(10,) }) == (10)));
-    assert!(((unsafe { apply_4(Some(inc_0 as unsafe fn(i32) -> i32), 5,) }) == (6)));
+    assert!(((unsafe { apply_4(Some(inc_0), 5,) }) == (6)));
     assert!(((unsafe { apply_4(None, 5,) }) == (5)));
     return 0;
 }