From 8a5ff584f242fd05a3b488e153381f615ceb03e6 Mon Sep 17 00:00:00 2001 From: Perfloop Agent Date: Fri, 20 Nov 2026 18:07:39 +0000 Subject: [PATCH] Evaluate fixed operands before hoisted emplacement construction Signed-off-by: Perfloop Agent --- cpp2rust/converter/converter.cpp | 23 +++- tests/unit/emplace_hint_receiver_order.cpp | 30 ++++++ tests/unit/emplace_receiver_alias.cpp | 21 ++++ tests/unit/emplace_receiver_order.cpp | 29 +++++ .../refcount/emplace_hint_receiver_order.rs | 100 ++++++++++++++++++ .../out/refcount/emplace_receiver_alias.rs | 54 ++++++++++ .../out/refcount/emplace_receiver_order.rs | 85 +++++++++++++++ tests/unit/out/refcount/map.rs | 51 ++++----- .../out/unsafe/emplace_hint_receiver_order.rs | 96 +++++++++++++++++ .../unit/out/unsafe/emplace_receiver_alias.rs | 51 +++++++++ .../unit/out/unsafe/emplace_receiver_order.rs | 87 +++++++++++++++ 11 files changed, 598 insertions(+), 29 deletions(-) create mode 100644 tests/unit/emplace_hint_receiver_order.cpp create mode 100644 tests/unit/emplace_receiver_alias.cpp create mode 100644 tests/unit/emplace_receiver_order.cpp create mode 100644 tests/unit/out/refcount/emplace_hint_receiver_order.rs create mode 100644 tests/unit/out/refcount/emplace_receiver_alias.rs create mode 100644 tests/unit/out/refcount/emplace_receiver_order.rs create mode 100644 tests/unit/out/unsafe/emplace_hint_receiver_order.rs create mode 100644 tests/unit/out/unsafe/emplace_receiver_alias.rs create mode 100644 tests/unit/out/unsafe/emplace_receiver_order.rs diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 2dc31aa54..362b3a3a3 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -5795,17 +5795,30 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args, ReturnsPointerToArg(all_args[base->n])) { bind[base->n] = true; } - - auto first = ArgsToEvaluateFirst(expr, *tgt_ir, all_args, bind); + // Construction happens inside the C++ call, after its fixed operands. + // Plan fixed-operand bindings before checking for conflicting init borrows. + auto num_params = std::min(tgt_ir->params.size(), all_args.size()); + bool always_constructs_init = tgt_ir->alwaysConstructsInit(); + auto init_bind = bind; + if (always_constructs_init && HasReceiver(expr)) { + for (size_t i = 0; i < num_params; ++i) { + init_bind[i] = init_bind[i] || all_args[i]->HasSideEffects(ctx_); + } + } + auto first = ArgsToEvaluateFirst(expr, *tgt_ir, all_args, init_bind); // The object that init constructs is constructed first, rather than its // arguments evaluated first one by one, and once if the body uses it more // than once. - auto num_params = std::min(tgt_ir->params.size(), all_args.size()); bool init_first = - tgt_ir->alwaysConstructsInit() && + always_constructs_init && (tgt_ir->initCopies() > 1 || std::find(first.begin() + num_params, first.end(), true) != first.end()); - + if (init_first) { + bind = std::move(init_bind); + } else if (init_bind != bind) { + // A declined plan must not hide bindings needed by the original borrows. + first = ArgsToEvaluateFirst(expr, *tgt_ir, all_args, bind); + } std::vector values, names; bool all_by_value = true; diff --git a/tests/unit/emplace_hint_receiver_order.cpp b/tests/unit/emplace_hint_receiver_order.cpp new file mode 100644 index 000000000..5eec9a5e7 --- /dev/null +++ b/tests/unit/emplace_hint_receiver_order.cpp @@ -0,0 +1,30 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++17 + +#include +#include +#include +using Map = std::map>; +Map *receiver(Map *m, std::vector *v, int *calls) { + ++*calls; + (*v)[2] = 9; + return m; +} +Map::iterator hint(Map *m, std::vector *v, int *calls) { + ++*calls; + (*v)[2] = 7; + return m->end(); +} +int main() { + for (int select_receiver = 1; select_receiver >= 0; --select_receiver) { + Map m; + std::vector v{1, 2, 3}; + int a = 0, b = 0; + if (select_receiver) + receiver(&m, &v, &a)->emplace_hint(hint(&m, &v, &b), 1, v); + else + m.emplace_hint(hint(&m, &v, &b), 1, v); + const std::vector &inserted = m.at(1); + std::printf("receiver=%d hint=%d source=%d inserted=%d\n", a, b, v[2], + inserted[2]); + } +} diff --git a/tests/unit/emplace_receiver_alias.cpp b/tests/unit/emplace_receiver_alias.cpp new file mode 100644 index 000000000..5f651278b --- /dev/null +++ b/tests/unit/emplace_receiver_alias.cpp @@ -0,0 +1,21 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++14 + +#include +#include + +using Rows = std::vector>; + +Rows *select_rows(Rows *rows, int *calls) { + ++*calls; + return rows; +} + +int main() { + Rows rows{{1, 2, 3}}; + rows.reserve(2); + int calls = 0; + Rows *alias = &rows; + select_rows(alias, &calls) + ->emplace_back((*alias)[0].data(), (*alias)[0].data() + 3); + std::printf("calls=%d size=%zu last=%d\n", calls, rows.size(), rows[1][2]); +} diff --git a/tests/unit/emplace_receiver_order.cpp b/tests/unit/emplace_receiver_order.cpp new file mode 100644 index 000000000..074081cd1 --- /dev/null +++ b/tests/unit/emplace_receiver_order.cpp @@ -0,0 +1,29 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++14 + +#include +#include + +using Rows = std::vector>; + +Rows *select_rows(Rows *rows, int *calls) { + ++*calls; + (*rows)[0][2] = 9; + return rows; +} + +int main() { + for (int bound = 0; bound < 2; ++bound) { + Rows rows{{1, 2, 3}}; + rows.reserve(2); + int calls = 0; + if (bound) { + Rows *receiver = select_rows(&rows, &calls); + receiver->emplace_back(rows[0].data(), rows[0].data() + 3); + } else { + select_rows(&rows, &calls) + ->emplace_back(rows[0].data(), rows[0].data() + 3); + } + std::printf("source=%d inserted=%d calls=%d\n", rows[0][2], rows[1][2], + calls); + } +} diff --git a/tests/unit/out/refcount/emplace_hint_receiver_order.rs b/tests/unit/out/refcount/emplace_hint_receiver_order.rs new file mode 100644 index 000000000..bade6ff44 --- /dev/null +++ b/tests/unit/out/refcount/emplace_hint_receiver_order.rs @@ -0,0 +1,100 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +pub fn receiver_0( + mut m: Ptr, Value>)>>, + mut v: Ptr>, + mut calls: Ptr, +) -> Ptr, Value>)>> { + calls.with_mut(|__v| { + __v.prefix_inc(); + }); + index!(v, 2_usize).write(9); + return m; +} +pub fn hint_1( + mut m: Ptr, Value>)>>, + mut v: Ptr>, + mut calls: Ptr, +) -> BidirectionalIterator<(Value, Value>)> { + calls.with_mut(|__v| { + __v.prefix_inc(); + }); + index!(v, 2_usize).write(7); + return m.with(|__m: &Map, Value>)>| __m.end()); +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + { + let mut select_receiver: i32 = 1; + 'loop_: while (select_receiver >= 0) { + let m: Value, Value>)>> = + Rc::new(RefCell::new(Map::new())); + let v: Value> = Rc::new(RefCell::new(Vec::from([1, 2, 3]))); + let a: Value = Rc::new(RefCell::new(0)); + let b: Value = Rc::new(RefCell::new(0)); + if (select_receiver != 0) { + { + let mut __tmp_0 = + { ({ receiver_0((m.as_pointer()), (v.as_pointer()), (a.as_pointer())) }) }; + let mut __tmp_1 = { + , Value>)>>::from( + ({ hint_1((m.as_pointer()), (v.as_pointer()), (b.as_pointer())) }), + ) + }; + let mut __tmp_2 = { + ( + Rc::new(RefCell::new(1)), + Rc::new(RefCell::new(({ (*v.borrow()).clone() }))), + ) + }; + let _ = (__tmp_1).clone(); + Map::emplace((__tmp_0).clone(), &__tmp_2.0.as_pointer(), || __tmp_2).0 + }; + } else { + { + let mut __tmp_3 = { + , Value>)>>::from( + ({ hint_1((m.as_pointer()), (v.as_pointer()), (b.as_pointer())) }), + ) + }; + let mut __tmp_4 = { + ( + Rc::new(RefCell::new(1)), + Rc::new(RefCell::new(({ (*v.borrow()).clone() }))), + ) + }; + let _ = (__tmp_3).clone(); + Map::emplace(m.as_pointer(), &__tmp_4.0.as_pointer(), || __tmp_4).0 + }; + } + let inserted: Ptr> = ({ + let __tmp_5: Value = Rc::new(RefCell::new(1)); + (*m.borrow()) + .get(&__tmp_5.as_pointer()) + .expect("out of range!") + .borrow() + .1 + .as_pointer() + }); + printf!( + b"receiver=%d hint=%d source=%d inserted=%d\n", + (*a.borrow()), + (*b.borrow()), + { (*v.borrow())[2_usize] }, + (index!(inserted, 2_usize).read()) + ); + select_receiver.prefix_dec(); + } + } + 0 +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/emplace_receiver_alias.rs b/tests/unit/out/refcount/emplace_receiver_alias.rs new file mode 100644 index 000000000..70a126755 --- /dev/null +++ b/tests/unit/out/refcount/emplace_receiver_alias.rs @@ -0,0 +1,54 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +pub fn select_rows_0(mut rows: Ptr>>, mut calls: Ptr) -> Ptr>> { + calls.with_mut(|__v| { + __v.prefix_inc(); + }); + return rows; +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + let rows: Value>> = Rc::new(RefCell::new(Vec::from([Vec::from([1, 2, 3])]))); + rows.with_mut(|__b0| { + if 2_usize > (*__b0).capacity() as usize { + let len_0 = (*__b0).len(); + (*__b0).reserve_exact(2_usize - len_0 as usize); + } + }); + let calls: Value = Rc::new(RefCell::new(0)); + let mut alias: Ptr>> = (rows.as_pointer()); + { + let mut __tmp_0 = { ({ select_rows_0((alias).clone(), (calls.as_pointer())) }) }; + let mut __tmp_3 = { + { + let mut __tmp_1 = { (alias).decay().offset(0_usize).decay() }; + let mut __tmp_2 = { (alias).decay().offset(0_usize).decay().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = (__tmp_1).clone(); + while __it != __tmp_2 { + __v.push((__it.iter_deref().read())); + __it.iter_inc(); + } + __v + } + }; + __tmp_0.with_mut(|__v: &mut Vec>| __v.push(__tmp_3)) + }; + printf!( + b"calls=%d size=%zu last=%d\n", + (*calls.borrow()), + (*rows.borrow()).len(), + (index!(elem!(rows.decay(), 1_usize), 2_usize).read()) + ); + 0 +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/emplace_receiver_order.rs b/tests/unit/out/refcount/emplace_receiver_order.rs new file mode 100644 index 000000000..5b86707e1 --- /dev/null +++ b/tests/unit/out/refcount/emplace_receiver_order.rs @@ -0,0 +1,85 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +pub fn select_rows_0(mut rows: Ptr>>, mut calls: Ptr) -> Ptr>> { + calls.with_mut(|__v| { + __v.prefix_inc(); + }); + index!(index!(rows, 0_usize), 2_usize).write(9); + return rows; +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + { + let mut bound: i32 = 0; + 'loop_: while (bound < 2) { + let rows: Value>> = + Rc::new(RefCell::new(Vec::from([Vec::from([1, 2, 3])]))); + rows.with_mut(|__b0| { + if 2_usize > (*__b0).capacity() as usize { + let len_0 = (*__b0).len(); + (*__b0).reserve_exact(2_usize - len_0 as usize); + } + }); + let calls: Value = Rc::new(RefCell::new(0)); + if (bound != 0) { + let mut receiver: Ptr>> = + ({ select_rows_0((rows.as_pointer()), (calls.as_pointer())) }); + { + let mut __tmp_2 = { + { + let mut __tmp_0 = { rows.decay().offset(0_usize).decay() }; + let mut __tmp_1 = + { rows.decay().offset(0_usize).decay().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = (__tmp_0).clone(); + while __it != __tmp_1 { + __v.push((__it.iter_deref().read())); + __it.iter_inc(); + } + __v + } + }; + receiver.with_mut(|__v: &mut Vec>| __v.push(__tmp_2)) + }; + } else { + { + let mut __tmp_3 = + { ({ select_rows_0((rows.as_pointer()), (calls.as_pointer())) }) }; + let mut __tmp_6 = { + { + let mut __tmp_4 = { rows.decay().offset(0_usize).decay() }; + let mut __tmp_5 = + { rows.decay().offset(0_usize).decay().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = (__tmp_4).clone(); + while __it != __tmp_5 { + __v.push((__it.iter_deref().read())); + __it.iter_inc(); + } + __v + } + }; + __tmp_3.with_mut(|__v: &mut Vec>| __v.push(__tmp_6)) + }; + } + printf!( + b"source=%d inserted=%d calls=%d\n", + (index!(elem!(rows.decay(), 0_usize), 2_usize).read()), + (index!(elem!(rows.decay(), 1_usize), 2_usize).read()), + (*calls.borrow()) + ); + bound.prefix_inc(); + } + } + 0 +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs index 6f0f0142e..57d8f5252 100644 --- a/tests/unit/out/refcount/map.rs +++ b/tests/unit/out/refcount/map.rs @@ -643,12 +643,15 @@ fn main_0() -> i32 { == 5) ); let hinted: Value, Value)>> = Rc::new(RefCell::new({ - let mut __tmp_48 = { (Rc::new(RefCell::new(6)), Rc::new(RefCell::new(7))) }; - let _ = , Value)>>::from( - m3.as_pointer() - .with(|__m: &Map, Value)>| __m.end()), - ); - Map::emplace(m3.as_pointer(), &__tmp_48.0.as_pointer(), || __tmp_48).0 + let mut __tmp_48 = { + , Value)>>::from( + m3.as_pointer() + .with(|__m: &Map, Value)>| __m.end()), + ) + }; + let mut __tmp_49 = { (Rc::new(RefCell::new(6)), Rc::new(RefCell::new(7))) }; + let _ = (__tmp_48).clone(); + Map::emplace(m3.as_pointer(), &__tmp_49.0.as_pointer(), || __tmp_49).0 })); assert!( ({ @@ -704,8 +707,8 @@ fn main_0() -> i32 { assert!(({ ((*(*tried_new.borrow()).1.borrow()) as bool) })); assert!( ((match (Rc::new(RefCell::new(8)).as_pointer(),) { - (__tmp_49,) => { - ({ (*m3.borrow_mut()).subscript_move(__tmp_49, |__k| cpp_move!(__k), || 0_i32) }) + (__tmp_50,) => { + ({ (*m3.borrow_mut()).subscript_move(__tmp_50, |__k| cpp_move!(__k), || 0_i32) }) } } .read()) @@ -731,10 +734,10 @@ fn main_0() -> i32 { assert!(({ ((*(*point_new.borrow()).1.borrow()) as bool) })); assert!( (match (Rc::new(RefCell::new(1)).as_pointer(),) { - (__tmp_50,) => { + (__tmp_51,) => { ({ (*points.borrow_mut()).subscript_move( - __tmp_50, + __tmp_51, |__k| cpp_move!(__k), || ::default(), ) @@ -746,10 +749,10 @@ fn main_0() -> i32 { ); assert!( (match (Rc::new(RefCell::new(1)).as_pointer(),) { - (__tmp_51,) => { + (__tmp_52,) => { ({ (*points.borrow_mut()).subscript_move( - __tmp_51, + __tmp_52, |__k| cpp_move!(__k), || ::default(), ) @@ -760,14 +763,14 @@ fn main_0() -> i32 { == 4) ); { - let mut __tmp_52 = { + let mut __tmp_53 = { ( Rc::new(RefCell::new(({ (*key8.borrow()) }))), Rc::new(RefCell::new(Point::new_2({ 5 }, { 6 }))), ) }; let (__it, __inserted) = - Map::emplace(points.as_pointer(), &__tmp_52.0.as_pointer(), || __tmp_52); + Map::emplace(points.as_pointer(), &__tmp_53.0.as_pointer(), || __tmp_53); ( Rc::new(RefCell::new(__it)), Rc::new(RefCell::new(__inserted)), @@ -775,10 +778,10 @@ fn main_0() -> i32 { }; assert!( (match (Rc::new(RefCell::new(8)).as_pointer(),) { - (__tmp_53,) => { + (__tmp_54,) => { ({ (*points.borrow_mut()).subscript_move( - __tmp_53, + __tmp_54, |__k| cpp_move!(__k), || ::default(), ) @@ -790,10 +793,10 @@ fn main_0() -> i32 { ); assert!( (match (Rc::new(RefCell::new(8)).as_pointer(),) { - (__tmp_54,) => { + (__tmp_55,) => { ({ (*points.borrow_mut()).subscript_move( - __tmp_54, + __tmp_55, |__k| cpp_move!(__k), || ::default(), ) @@ -836,9 +839,9 @@ fn main_0() -> i32 { ); k = 0; let value_0: Ptr = ({ - let __tmp_55: Value = Rc::new(RefCell::new((k as i16))); + let __tmp_56: Value = Rc::new(RefCell::new((k as i16))); (*m.borrow()) - .get(&__tmp_55.as_pointer()) + .get(&__tmp_56.as_pointer()) .expect("out of range!") .borrow() .1 @@ -877,10 +880,10 @@ fn main_0() -> i32 { ); { match (Rc::new(RefCell::new((pk2.as_pointer()))).as_pointer(),) { - (__tmp_56,) => { + (__tmp_57,) => { ({ (*ptr_counts.borrow_mut()).subscript_move( - __tmp_56, + __tmp_57, |__k| cpp_move!(__k), || 0_i32, ) @@ -891,10 +894,10 @@ fn main_0() -> i32 { }; assert!( ((match (Rc::new(RefCell::new((pk2.as_pointer()))).as_pointer(),) { - (__tmp_57,) => { + (__tmp_58,) => { ({ (*ptr_counts.borrow_mut()).subscript_move( - __tmp_57, + __tmp_58, |__k| cpp_move!(__k), || 0_i32, ) diff --git a/tests/unit/out/unsafe/emplace_hint_receiver_order.rs b/tests/unit/out/unsafe/emplace_hint_receiver_order.rs new file mode 100644 index 000000000..0cfdb0816 --- /dev/null +++ b/tests/unit/out/unsafe/emplace_hint_receiver_order.rs @@ -0,0 +1,96 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub unsafe fn receiver_0( + mut m: *mut UnsafeMap)>, + mut v: *mut Vec, + mut calls: *mut i32, +) -> *mut UnsafeMap)> { + (*calls).prefix_inc(); + (&mut (*v))[(2_usize)] = 9; + return m; +} +pub unsafe fn hint_1( + mut m: *mut UnsafeMap)>, + mut v: *mut Vec, + mut calls: *mut i32, +) -> UnsafeBidirectionalIterator<(i32, Vec)> { + (*calls).prefix_inc(); + (&mut (*v))[(2_usize)] = 7; + return (*m).end(); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + { + let mut select_receiver: i32 = 1; + 'loop_: while ((select_receiver) >= (0)) { + let mut m: UnsafeMap)> = UnsafeMap::new(); + let mut v: Vec = Vec::from([1, 2, 3]); + let mut a: i32 = 0; + let mut b: i32 = 0; + if (select_receiver != 0) { + { + let mut __tmp_0 = { + (unsafe { + receiver_0( + (&mut m as *mut UnsafeMap)>), + (&mut v as *mut Vec), + (&mut a as *mut i32), + ) + }) + }; + let mut __tmp_1 = { + )>>::from( + (unsafe { + hint_1( + (&mut m as *mut UnsafeMap)>), + (&mut v as *mut Vec), + (&mut b as *mut i32), + ) + }), + ) + }; + let mut __tmp_2 = { (1, (v).clone()) }; + let _ = (__tmp_1).clone(); + (*__tmp_0).emplace(__tmp_2).0 + }; + } else { + { + let _ = )>>::from( + (unsafe { + hint_1( + (&mut m as *mut UnsafeMap)>), + (&mut v as *mut Vec), + (&mut b as *mut i32), + ) + }), + ); + m.emplace((1, (v).clone())).0 + }; + } + let inserted: *const Vec = &raw const (*m.get(&1).expect("out of range!")).1; + (unsafe { + libc::printf( + c"receiver=%d hint=%d source=%d inserted=%d\n".as_ptr() as *const libc::c_char, + (a), + (b), + (v[(2_usize)]), + ((&(*inserted))[(2_usize)]), + ) + }); + select_receiver.prefix_dec(); + } + } + 0 +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/emplace_receiver_alias.rs b/tests/unit/out/unsafe/emplace_receiver_alias.rs new file mode 100644 index 000000000..7151a6602 --- /dev/null +++ b/tests/unit/out/unsafe/emplace_receiver_alias.rs @@ -0,0 +1,51 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub unsafe fn select_rows_0( + mut rows: *mut Vec>, + mut calls: *mut i32, +) -> *mut Vec> { + (*calls).prefix_inc(); + return rows; +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut rows: Vec> = Vec::from([Vec::from([1, 2, 3])]); + if 2_usize > rows.capacity() as usize { + let len_0 = rows.len(); + rows.reserve_exact(2_usize - len_0 as usize); + }; + let mut calls: i32 = 0; + let mut alias: *mut Vec> = (&mut rows as *mut Vec>); + (*(unsafe { select_rows_0(alias, (&mut calls as *mut i32)) })).push({ + let mut __tmp_0 = { (&mut (*alias))[(0_usize)].as_mut_ptr() }; + let mut __tmp_1 = { (&mut (*alias))[(0_usize)].as_mut_ptr().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = __tmp_0; + while __it != __tmp_1 { + __v.push((*__it.iter_deref())); + __it.iter_inc(); + } + __v + }); + (unsafe { + libc::printf( + c"calls=%d size=%zu last=%d\n".as_ptr() as *const libc::c_char, + (calls), + (rows.len()), + (rows[(1_usize)][(2_usize)]), + ) + }); + 0 +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/emplace_receiver_order.rs b/tests/unit/out/unsafe/emplace_receiver_order.rs new file mode 100644 index 000000000..2af011630 --- /dev/null +++ b/tests/unit/out/unsafe/emplace_receiver_order.rs @@ -0,0 +1,87 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub unsafe fn select_rows_0( + mut rows: *mut Vec>, + mut calls: *mut i32, +) -> *mut Vec> { + (*calls).prefix_inc(); + (&mut (*rows))[(0_usize)][(2_usize)] = 9; + return rows; +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + { + let mut bound: i32 = 0; + 'loop_: while ((bound) < (2)) { + let mut rows: Vec> = Vec::from([Vec::from([1, 2, 3])]); + if 2_usize > rows.capacity() as usize { + let len_0 = rows.len(); + rows.reserve_exact(2_usize - len_0 as usize); + }; + let mut calls: i32 = 0; + if (bound != 0) { + let mut receiver: *mut Vec> = (unsafe { + select_rows_0((&mut rows as *mut Vec>), (&mut calls as *mut i32)) + }); + (*receiver).push({ + let mut __tmp_0 = { rows[(0_usize)].as_mut_ptr() }; + let mut __tmp_1 = { rows[(0_usize)].as_mut_ptr().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = __tmp_0; + while __it != __tmp_1 { + __v.push((*__it.iter_deref())); + __it.iter_inc(); + } + __v + }); + } else { + { + let mut __tmp_2 = { + (unsafe { + select_rows_0( + (&mut rows as *mut Vec>), + (&mut calls as *mut i32), + ) + }) + }; + let mut __tmp_5 = { + { + let mut __tmp_3 = { rows[(0_usize)].as_mut_ptr() }; + let mut __tmp_4 = { rows[(0_usize)].as_mut_ptr().offset((3) as isize) }; + let mut __v = Vec::new(); + let mut __it = __tmp_3; + while __it != __tmp_4 { + __v.push((*__it.iter_deref())); + __it.iter_inc(); + } + __v + } + }; + (*__tmp_2).push(__tmp_5) + }; + } + (unsafe { + libc::printf( + c"source=%d inserted=%d calls=%d\n".as_ptr() as *const libc::c_char, + (rows[(0_usize)][(2_usize)]), + (rows[(1_usize)][(2_usize)]), + (calls), + ) + }); + bound.prefix_inc(); + } + } + 0 +} +pub unsafe fn __cpp2rust_init_globals() {}