Handle std::forward in converter

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1850,7 +1850,7 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (expr->isCallToStdMove()) {
+  if (expr->isCallToStdMove() || IsCallToStdForward(expr)) {
     Convert(expr->getArg(0));
     return false;
   }
@@ -2173,7 +2173,7 @@ Converter::ConvertCallExpr(clang::CallExpr *expr) {
   if (auto fn = Mapper::ToString(callee);
       fn.starts_with("int printf") || fn.starts_with("int fprintf")) {
     ConvertPrintf(expr);
-  } else if (expr->isCallToStdMove()) {
+  } else if (expr->isCallToStdMove() || IsCallToStdForward(expr)) {
     Convert(expr->getArg(0));
   } else if (IsBuiltinConstantP(callee)) {
     StrCat(expr->getArg(0)->isCXX11ConstantExpr(ctx_) ? token::kOne
@@ -2833,7 +2833,7 @@ void Converter::ConvertGenericBinaryOperator(clang::BinaryOperator *expr) {
 }
 
 bool Converter::IsReferenceType(const clang::Expr *expr) const {
-  const auto *e = IgnoreStdMove(expr->IgnoreCasts())->IgnoreCasts();
+  const auto *e = IgnoreStdMoveAndForward(expr->IgnoreCasts())->IgnoreCasts();
   if (const auto *call = clang::dyn_cast<clang::CallExpr>(e)) {
     return !clang::isa<clang::CXXOperatorCallExpr>(call) &&
            GetReturnTypeOfFunction(call)->isReferenceType();

cpp2rust/converter/converter_lib.cpp

@@ -1435,17 +1435,27 @@ bool IsBuiltinVaCopy(const clang::CallExpr *expr) {
   return false;
 }
 
-const clang::Expr *IgnoreStdMove(const clang::Expr *expr) {
+bool IsCallToStdForward(const clang::CallExpr *expr) {
+  const auto *callee = expr->getDirectCallee();
+  if (!callee) {
+    return false;
+  }
+  const auto builtin_id = callee->getBuiltinID();
+  return builtin_id == clang::Builtin::BIforward ||
+         builtin_id == clang::Builtin::BIforward_like;
+}
+
+const clang::Expr *IgnoreStdMoveAndForward(const clang::Expr *expr) {
   if (const auto *call =
           clang::dyn_cast<clang::CallExpr>(expr->IgnoreParenImpCasts());
-      call && call->isCallToStdMove()) {
+      call && (call->isCallToStdMove() || IsCallToStdForward(call))) {
     return call->getArg(0);
   }
   return expr;
 }
 
 bool IsTemporaryObject(const clang::Expr *expr) {
-  const auto *operand = IgnoreStdMove(expr);
+  const auto *operand = IgnoreStdMoveAndForward(expr);
   if (operand != expr) {
     return !operand->isGLValue();
   }

cpp2rust/converter/converter_lib.h

@@ -262,7 +262,9 @@ bool IsBuiltinVaEnd(const clang::CallExpr *expr);
 
 bool IsBuiltinVaCopy(const clang::CallExpr *expr);
 
-const clang::Expr *IgnoreStdMove(const clang::Expr *expr);
+bool IsCallToStdForward(const clang::CallExpr *expr);
+
+const clang::Expr *IgnoreStdMoveAndForward(const clang::Expr *expr);
 
 bool IsTemporaryObject(const clang::Expr *expr);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -1170,7 +1170,7 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (expr->isCallToStdMove()) {
+  if (expr->isCallToStdMove() || IsCallToStdForward(expr)) {
     return Converter::VisitCallExpr(expr);
   }
 
@@ -2772,7 +2772,7 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
   auto arg_idx = receiver_ph->n;
   auto *arg = BuildUnifiedArgs(expr, args, num_args)[arg_idx];
   if (auto *call = clang::dyn_cast<clang::CallExpr>(arg->IgnoreCasts());
-      call && call->isCallToStdMove()) {
+      call && (call->isCallToStdMove() || IsCallToStdForward(call))) {
     arg = call->getArg(0);
   }
 

tests/unit/out/refcount/forward_decltype.rs

@@ -82,21 +82,21 @@ pub fn chosen_overload_1(_a0: Ptr<Tracked>) -> Overload {
     return Overload_kRvalueOverload;
 }
 pub fn forward_by_decltype_2(x: Ptr<Tracked>) -> Overload {
-    return ({ chosen_overload_0(({ forward_3((x).clone()) })) });
+    return ({ chosen_overload_0((x).clone()) });
 }
-pub fn forward_by_decltype_4(x: Ptr<Tracked>) -> Overload {
-    return ({ chosen_overload_1(({ forward_5((x).clone()) })) });
+pub fn forward_by_decltype_3(x: Ptr<Tracked>) -> Overload {
+    return ({ chosen_overload_1((x).clone()) });
 }
-pub fn forward_abbreviated_6(x: Ptr<Tracked>) -> Overload {
-    return ({ chosen_overload_0(({ forward_3((x).clone()) })) });
+pub fn forward_abbreviated_4(x: Ptr<Tracked>) -> Overload {
+    return ({ chosen_overload_0((x).clone()) });
 }
-pub fn forward_abbreviated_7(x: Ptr<Tracked>) -> Overload {
-    return ({ chosen_overload_1(({ forward_5((x).clone()) })) });
+pub fn forward_abbreviated_5(x: Ptr<Tracked>) -> Overload {
+    return ({ chosen_overload_1((x).clone()) });
 }
-pub fn forward_abbreviated_pack_8(args_0: Ptr<Tracked>, args_1: Ptr<Tracked>) -> i32 {
+pub fn forward_abbreviated_pack_6(args_0: Ptr<Tracked>, args_1: Ptr<Tracked>) -> i32 {
     return {
-        let _lhs = (({ chosen_overload_0(({ forward_3((args_0).clone()) })) }) as i32);
-        _lhs + (({ chosen_overload_1(({ forward_5((args_1).clone()) })) }) as i32)
+        let _lhs = (({ chosen_overload_0((args_0).clone()) }) as i32);
+        _lhs + (({ chosen_overload_1((args_1).clone()) }) as i32)
     };
 }
 pub fn main() {
@@ -113,28 +113,28 @@ fn main_0() -> i32 {
     assert!(
         ((({
             let _x: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 4 })));
-            forward_by_decltype_4(_x.as_pointer())
+            forward_by_decltype_3(_x.as_pointer())
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let b: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 5 })));
     assert!(
-        ((({ forward_abbreviated_6(b.as_pointer(),) }) as i32)
+        ((({ forward_abbreviated_4(b.as_pointer(),) }) as i32)
             == (Overload_kLvalueOverload as i32))
     );
     assert!(((*(*b.borrow()).v.borrow()) == 5));
     assert!(
         ((({
             let _x: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 6 })));
-            forward_abbreviated_7(_x.as_pointer())
+            forward_abbreviated_5(_x.as_pointer())
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let c: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 7 })));
     assert!(
         (({
             let _args: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 8 })));
-            forward_abbreviated_pack_8(c.as_pointer(), _args.as_pointer())
+            forward_abbreviated_pack_6(c.as_pointer(), _args.as_pointer())
         }) == ((Overload_kLvalueOverload as i32) + (Overload_kRvalueOverload as i32)))
     );
     assert!(((*(*c.borrow()).v.borrow()) == 7));

tests/unit/out/refcount/forward_explicit.rs

@@ -100,51 +100,38 @@ pub fn main() {
 fn main_0() -> i32 {
     let a: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 5 })));
     assert!(
-        ((({ chosen_overload_0(({ forward_5(a.as_pointer(),) }),) }) as i32)
-            == (Overload_kLvalueOverload as i32))
+        ((({ chosen_overload_0(a.as_pointer(),) }) as i32) == (Overload_kLvalueOverload as i32))
     );
     assert!(((*(*a.borrow()).v.borrow()) == 5));
     assert!(
-        ((({ chosen_overload_1(({ forward_6(a.as_pointer(),) }),) }) as i32)
-            == (Overload_kRvalueOverload as i32))
+        ((({ chosen_overload_1(a.as_pointer(),) }) as i32) == (Overload_kRvalueOverload as i32))
     );
     assert!(((*(*a.borrow()).v.borrow()) == 5));
     let b: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 6 })));
     let moved: Value<Tracked> = Rc::new(RefCell::new(
-        ({
-            copy_or_move_into_param_4(Tracked::Tracked_pmutTracked_rv({
-                ({ forward_6(b.as_pointer()) })
-            }))
-        }),
+        ({ copy_or_move_into_param_4(Tracked::Tracked_pmutTracked_rv({ b.as_pointer() })) }),
     ));
     assert!(((*(*moved.borrow()).v.borrow()) == 6));
     assert!(((*(*moved.borrow()).copies.borrow()) == 0));
     assert!(((*(*moved.borrow()).moves.borrow()) == 2));
     assert!(((*(*b.borrow()).v.borrow()) == 0));
     let c: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 7 })));
     let copied: Value<Tracked> = Rc::new(RefCell::new(
-        ({
-            copy_or_move_into_param_4(Tracked::Tracked_pconstTracked({
-                ({ forward_5(c.as_pointer()) })
-            }))
-        }),
+        ({ copy_or_move_into_param_4(Tracked::Tracked_pconstTracked({ c.as_pointer() })) }),
     ));
     assert!(((*(*copied.borrow()).v.borrow()) == 7));
     assert!(((*(*copied.borrow()).copies.borrow()) == 1));
     assert!(((*(*copied.borrow()).moves.borrow()) == 1));
     assert!(((*(*c.borrow()).v.borrow()) == 7));
     let i: Value<i32> = Rc::new(RefCell::new(8));
     assert!(
-        ((({ chosen_overload_2(({ forward_7(i.as_pointer(),) }),) }) as i32)
-            == (Overload_kIntLvalueOverload as i32))
+        ((({ chosen_overload_2(i.as_pointer(),) }) as i32) == (Overload_kIntLvalueOverload as i32))
     );
     assert!(
-        ((({ chosen_overload_3(({ forward_8(i.as_pointer(),) }),) }) as i32)
-            == (Overload_kIntRvalueOverload as i32))
+        ((({ chosen_overload_3(i.as_pointer(),) }) as i32) == (Overload_kIntRvalueOverload as i32))
     );
     assert!(
-        ((({ chosen_overload_3(({ forward_9(i.as_pointer(),) }),) }) as i32)
-            == (Overload_kIntRvalueOverload as i32))
+        ((({ chosen_overload_3(i.as_pointer(),) }) as i32) == (Overload_kIntRvalueOverload as i32))
     );
     assert!(((*i.borrow()) == 8));
     return 0;

tests/unit/out/unsafe/forward_basic.rs

@@ -57,15 +57,15 @@ pub unsafe fn chosen_overload_1(_a0: *mut Tracked) -> Overload {
 impl Holder {
     pub unsafe fn Holder1(x: *mut Tracked) -> Self {
         let mut this = Self {
-            t: Tracked::Tracked_pconstTracked({ (unsafe { forward_2(x) }) }),
+            t: Tracked::Tracked_pconstTracked({ x }),
         };
         this
     }
 }
 impl Holder {
     pub unsafe fn Holder2(x: *mut Tracked) -> Self {
         let mut this = Self {
-            t: Tracked::Tracked_pmutTracked_rv({ (unsafe { forward_3(x) }) }),
+            t: Tracked::Tracked_pmutTracked_rv({ x }),
         };
         this
     }
@@ -75,23 +75,23 @@ impl Holder {
 pub struct Holder {
     pub t: Tracked,
 }
-pub unsafe fn forward_once_4(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_0((unsafe { forward_2(x) })) });
+pub unsafe fn forward_once_2(x: *mut Tracked) -> Overload {
+    return (unsafe { chosen_overload_0(x) });
 }
-pub unsafe fn forward_once_5(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_1((unsafe { forward_3(x) })) });
+pub unsafe fn forward_once_3(x: *mut Tracked) -> Overload {
+    return (unsafe { chosen_overload_1(x) });
 }
-pub unsafe fn forward_twice_6(x: *mut Tracked) -> Overload {
-    return (unsafe { forward_once_4((unsafe { forward_2(x) })) });
+pub unsafe fn forward_twice_4(x: *mut Tracked) -> Overload {
+    return (unsafe { forward_once_2(x) });
 }
-pub unsafe fn forward_twice_7(x: *mut Tracked) -> Overload {
-    return (unsafe { forward_once_5((unsafe { forward_3(x) })) });
+pub unsafe fn forward_twice_5(x: *mut Tracked) -> Overload {
+    return (unsafe { forward_once_3(x) });
 }
-pub unsafe fn forward_into_ctor_8(x: *mut Tracked) -> Holder {
-    return Holder::Holder1({ (unsafe { forward_2(x) }) });
+pub unsafe fn forward_into_ctor_6(x: *mut Tracked) -> Holder {
+    return Holder::Holder1({ x });
 }
-pub unsafe fn forward_into_ctor_9(x: *mut Tracked) -> Holder {
-    return (*(unsafe { forward_3(x) }));
+pub unsafe fn forward_into_ctor_7(x: *mut Tracked) -> Holder {
+    return (*x);
 }
 pub fn main() {
     unsafe {
@@ -102,37 +102,37 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut lvalue: Tracked = Tracked::Tracked({ 7 });
     assert!(
-        (((unsafe { forward_once_4(&mut lvalue,) }) as i32) == (Overload_kLvalueOverload as i32))
+        (((unsafe { forward_once_2(&mut lvalue,) }) as i32) == (Overload_kLvalueOverload as i32))
     );
     assert!(((lvalue.v) == (7)));
     assert!(
         (((unsafe {
             let mut _x: Tracked = Tracked::Tracked({ 8 });
-            forward_once_5(&mut _x)
+            forward_once_3(&mut _x)
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let mut relayed: Tracked = Tracked::Tracked({ 9 });
     assert!(
-        (((unsafe { forward_twice_6(&mut relayed,) }) as i32) == (Overload_kLvalueOverload as i32))
+        (((unsafe { forward_twice_4(&mut relayed,) }) as i32) == (Overload_kLvalueOverload as i32))
     );
     assert!(((relayed.v) == (9)));
     assert!(
         (((unsafe {
             let mut _x: Tracked = Tracked::Tracked({ 10 });
-            forward_twice_7(&mut _x)
+            forward_twice_5(&mut _x)
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let mut kept: Tracked = Tracked::Tracked({ 11 });
-    let mut from_lvalue: Holder = (unsafe { forward_into_ctor_8(&mut kept) });
+    let mut from_lvalue: Holder = (unsafe { forward_into_ctor_6(&mut kept) });
     assert!(((from_lvalue.t.v) == (11)));
     assert!(((from_lvalue.t.copies) == (1)));
     assert!(((from_lvalue.t.moves) == (0)));
     assert!(((kept.v) == (11)));
     let mut from_rvalue: Holder = (unsafe {
         let mut _x: Tracked = Tracked::Tracked({ 12 });
-        forward_into_ctor_9(&mut _x)
+        forward_into_ctor_7(&mut _x)
     });
     assert!(((from_rvalue.t.v) == (12)));
     assert!(((from_rvalue.t.copies) == (0)));

tests/unit/out/unsafe/forward_decltype.rs

@@ -55,20 +55,20 @@ pub unsafe fn chosen_overload_1(_a0: *mut Tracked) -> Overload {
     return Overload_kRvalueOverload;
 }
 pub unsafe fn forward_by_decltype_2(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_0((unsafe { forward_3(x) })) });
+    return (unsafe { chosen_overload_0(x) });
 }
-pub unsafe fn forward_by_decltype_4(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_1((unsafe { forward_5(x) })) });
+pub unsafe fn forward_by_decltype_3(x: *mut Tracked) -> Overload {
+    return (unsafe { chosen_overload_1(x) });
 }
-pub unsafe fn forward_abbreviated_6(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_0((unsafe { forward_3(x) })) });
+pub unsafe fn forward_abbreviated_4(x: *mut Tracked) -> Overload {
+    return (unsafe { chosen_overload_0(x) });
 }
-pub unsafe fn forward_abbreviated_7(x: *mut Tracked) -> Overload {
-    return (unsafe { chosen_overload_1((unsafe { forward_5(x) })) });
+pub unsafe fn forward_abbreviated_5(x: *mut Tracked) -> Overload {
+    return (unsafe { chosen_overload_1(x) });
 }
-pub unsafe fn forward_abbreviated_pack_8(args_0: *mut Tracked, args_1: *mut Tracked) -> i32 {
-    return (((unsafe { chosen_overload_0((unsafe { forward_3(args_0) })) }) as i32)
-        + ((unsafe { chosen_overload_1((unsafe { forward_5(args_1) })) }) as i32));
+pub unsafe fn forward_abbreviated_pack_6(args_0: *mut Tracked, args_1: *mut Tracked) -> i32 {
+    return (((unsafe { chosen_overload_0(args_0) }) as i32)
+        + ((unsafe { chosen_overload_1(args_1) }) as i32));
 }
 pub fn main() {
     unsafe {
@@ -85,27 +85,27 @@ unsafe fn main_0() -> i32 {
     assert!(
         (((unsafe {
             let mut _x: Tracked = Tracked::Tracked({ 4 });
-            forward_by_decltype_4(&mut _x)
+            forward_by_decltype_3(&mut _x)
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let mut b: Tracked = Tracked::Tracked({ 5 });
     assert!(
-        (((unsafe { forward_abbreviated_6(&mut b,) }) as i32) == (Overload_kLvalueOverload as i32))
+        (((unsafe { forward_abbreviated_4(&mut b,) }) as i32) == (Overload_kLvalueOverload as i32))
     );
     assert!(((b.v) == (5)));
     assert!(
         (((unsafe {
             let mut _x: Tracked = Tracked::Tracked({ 6 });
-            forward_abbreviated_7(&mut _x)
+            forward_abbreviated_5(&mut _x)
         }) as i32)
             == (Overload_kRvalueOverload as i32))
     );
     let mut c: Tracked = Tracked::Tracked({ 7 });
     assert!(
         ((unsafe {
             let mut _args: Tracked = Tracked::Tracked({ 8 });
-            forward_abbreviated_pack_8(&mut c, &mut _args)
+            forward_abbreviated_pack_6(&mut c, &mut _args)
         }) == ((Overload_kLvalueOverload as i32) + (Overload_kRvalueOverload as i32)))
     );
     assert!(((c.v) == (7)));