Skip to content

Commit ae251a8

Browse files
lucic71lucic71
committed
Fix converting constructors and name of packs
1 parent 2723395 commit ae251a8

7 files changed

Lines changed: 215 additions & 13 deletions

File tree

‎cpp2rust/converter/converter.cpp‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1958,9 +1958,10 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
19581958
for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {
19591959
auto *arg = expr->getArg(i + arg_begin);
19601960
CallArg ca{
1961-
.param_name = function && !function->getParamDecl(i)->getName().empty()
1962-
? ("_" + function->getParamDecl(i)->getNameAsString())
1963-
: ("_arg" + std::to_string(i)),
1961+
.param_name =
1962+
function && !function->getParamDecl(i)->getName().empty()
1963+
? ("_" + GetNamedDeclAsString(function->getParamDecl(i)))
1964+
: ("_arg" + std::to_string(i)),
19641965
.param_type = function ? function->getParamDecl(i)->getType()
19651966
: proto->getParamType(i),
19661967
.expr = arg,

‎cpp2rust/converter/converter_lib.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -402,6 +402,7 @@ bool HasCallableCopyConstructor(const clang::RecordDecl *decl) {
402402

403403
bool IsRValueConvertingConstructor(const clang::CXXConstructorDecl *ctor) {
404404
return !ctor->isCopyOrMoveConstructor() &&
405+
!IsUserDefinedDecl(ctor->getParent()) &&
405406
ctor->isConvertingConstructor(false) && ctor->getNumParams() == 1 &&
406407
ctor->getParamDecl(0)->getType()->isRValueReferenceType();
407408
}

‎tests/unit/out/refcount/forward_basic.rs‎

Lines changed: 200 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,200 @@
1+
extern crate libcc2rs;
2+
use libcc2rs::*;
3+
use std::cell::RefCell;
4+
use std::collections::BTreeMap;
5+
use std::io::prelude::*;
6+
use std::io::{Read, Seek, Write};
7+
use std::os::fd::AsFd;
8+
use std::rc::{Rc, Weak};
9+
pub type Overload = u32;
10+
pub const Overload_kLvalueOverload: Overload = 1;
11+
pub const Overload_kRvalueOverload: Overload = 2;
12+
#[derive(Default)]
13+
pub struct Tracked {
14+
pub v: Value<i32>,
15+
pub copies: Value<i32>,
16+
pub moves: Value<i32>,
17+
}
18+
impl Tracked {
19+
pub fn Tracked(v: i32) -> Self {
20+
let v: Value<i32> = Rc::new(RefCell::new(v));
21+
let __this: Value<Tracked> = Rc::new(RefCell::new(Self {
22+
v: Rc::new(RefCell::new((*v.borrow()))),
23+
copies: Rc::new(RefCell::new(0)),
24+
moves: Rc::new(RefCell::new(0)),
25+
}));
26+
let this: Ptr<Tracked> = __this.as_pointer();
27+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
28+
}
29+
pub fn Tracked_pconstTracked(o: Ptr<Tracked>) -> Self {
30+
let __this: Value<Tracked> = Rc::new(RefCell::new(Self {
31+
v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
32+
copies: Rc::new(RefCell::new(
33+
((*(*o.upgrade().deref()).copies.borrow()) + 1),
34+
)),
35+
moves: Rc::new(RefCell::new((*(*o.upgrade().deref()).moves.borrow()))),
36+
}));
37+
let this: Ptr<Tracked> = __this.as_pointer();
38+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
39+
}
40+
pub fn Tracked_pmutTracked_rv(o: Ptr<Tracked>) -> Self {
41+
let __this: Value<Tracked> = Rc::new(RefCell::new(Self {
42+
v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
43+
copies: Rc::new(RefCell::new((*(*o.upgrade().deref()).copies.borrow()))),
44+
moves: Rc::new(RefCell::new(((*(*o.upgrade().deref()).moves.borrow()) + 1))),
45+
}));
46+
let this: Ptr<Tracked> = __this.as_pointer();
47+
(*(*o.upgrade().deref()).v.borrow_mut()) = 0;
48+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
49+
}
50+
}
51+
impl Clone for Tracked {
52+
fn clone(&self) -> Self {
53+
let __src: Value<Tracked> = Rc::new(RefCell::new(Tracked {
54+
v: self.v.clone(),
55+
copies: self.copies.clone(),
56+
moves: self.moves.clone(),
57+
}));
58+
Tracked::Tracked_pconstTracked(__src.as_pointer())
59+
}
60+
}
61+
impl ByteRepr for Tracked {
62+
fn byte_size() -> usize {
63+
12
64+
}
65+
fn to_bytes(&self, buf: &mut [u8]) {
66+
(*self.v.borrow()).to_bytes(&mut buf[0..4]);
67+
(*self.copies.borrow()).to_bytes(&mut buf[4..8]);
68+
(*self.moves.borrow()).to_bytes(&mut buf[8..12]);
69+
}
70+
fn from_bytes(buf: &[u8]) -> Self {
71+
Self {
72+
v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
73+
copies: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
74+
moves: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
75+
}
76+
}
77+
}
78+
pub fn chosen_overload_0(_a0: Ptr<Tracked>) -> Overload {
79+
return Overload_kLvalueOverload;
80+
}
81+
pub fn chosen_overload_1(_a0: Ptr<Tracked>) -> Overload {
82+
return Overload_kRvalueOverload;
83+
}
84+
impl Holder {
85+
pub fn Holder1(x: Ptr<Tracked>) -> Self {
86+
let __this: Value<Holder> = Rc::new(RefCell::new(Self {
87+
t: Rc::new(RefCell::new(Tracked::Tracked_pconstTracked({
88+
(x).clone()
89+
}))),
90+
}));
91+
let this: Ptr<Holder> = __this.as_pointer();
92+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
93+
}
94+
}
95+
impl Holder {
96+
pub fn Holder2(x: Ptr<Tracked>) -> Self {
97+
let __this: Value<Holder> = Rc::new(RefCell::new(Self {
98+
t: Rc::new(RefCell::new(Tracked::Tracked_pmutTracked_rv({
99+
(x).clone()
100+
}))),
101+
}));
102+
let this: Ptr<Holder> = __this.as_pointer();
103+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
104+
}
105+
}
106+
#[derive(Default)]
107+
pub struct Holder {
108+
pub t: Value<Tracked>,
109+
}
110+
impl Clone for Holder {
111+
fn clone(&self) -> Self {
112+
let __this: Value<Holder> = Rc::new(RefCell::new(Self {
113+
t: Rc::new(RefCell::new(Tracked::Tracked_pconstTracked({
114+
self.t.as_pointer()
115+
}))),
116+
}));
117+
let this: Ptr<Holder> = __this.as_pointer();
118+
Rc::try_unwrap(__this).ok().unwrap().into_inner()
119+
}
120+
}
121+
impl ByteRepr for Holder {
122+
fn byte_size() -> usize {
123+
12
124+
}
125+
fn to_bytes(&self, buf: &mut [u8]) {
126+
(*self.t.borrow()).to_bytes(&mut buf[0..12]);
127+
}
128+
fn from_bytes(buf: &[u8]) -> Self {
129+
Self {
130+
t: Rc::new(RefCell::new(<Tracked>::from_bytes(&buf[0..12]))),
131+
}
132+
}
133+
}
134+
pub fn forward_once_2(x: Ptr<Tracked>) -> Overload {
135+
return ({ chosen_overload_0((x).clone()) });
136+
}
137+
pub fn forward_once_3(x: Ptr<Tracked>) -> Overload {
138+
return ({ chosen_overload_1((x).clone()) });
139+
}
140+
pub fn forward_twice_4(x: Ptr<Tracked>) -> Overload {
141+
return ({ forward_once_2((x).clone()) });
142+
}
143+
pub fn forward_twice_5(x: Ptr<Tracked>) -> Overload {
144+
return ({ forward_once_3((x).clone()) });
145+
}
146+
pub fn forward_into_ctor_6(x: Ptr<Tracked>) -> Holder {
147+
return Holder::Holder1({ (x).clone() });
148+
}
149+
pub fn forward_into_ctor_7(x: Ptr<Tracked>) -> Holder {
150+
return Holder::Holder2({ (x).clone() });
151+
}
152+
pub fn main() {
153+
__cpp2rust_init_globals();
154+
std::process::exit(main_0());
155+
}
156+
fn main_0() -> i32 {
157+
let lvalue: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 7 })));
158+
assert!(
159+
((({ forward_once_2(lvalue.as_pointer(),) }) as i32) == (Overload_kLvalueOverload as i32))
160+
);
161+
assert!(((*(*lvalue.borrow()).v.borrow()) == 7));
162+
assert!(
163+
((({
164+
let _x: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 8 })));
165+
forward_once_3(_x.as_pointer())
166+
}) as i32)
167+
== (Overload_kRvalueOverload as i32))
168+
);
169+
let relayed: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 9 })));
170+
assert!(
171+
((({ forward_twice_4(relayed.as_pointer(),) }) as i32)
172+
== (Overload_kLvalueOverload as i32))
173+
);
174+
assert!(((*(*relayed.borrow()).v.borrow()) == 9));
175+
assert!(
176+
((({
177+
let _x: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 10 })));
178+
forward_twice_5(_x.as_pointer())
179+
}) as i32)
180+
== (Overload_kRvalueOverload as i32))
181+
);
182+
let kept: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 11 })));
183+
let from_lvalue: Value<Holder> =
184+
Rc::new(RefCell::new(({ forward_into_ctor_6(kept.as_pointer()) })));
185+
assert!(((*(*(*from_lvalue.borrow()).t.borrow()).v.borrow()) == 11));
186+
assert!(((*(*(*from_lvalue.borrow()).t.borrow()).copies.borrow()) == 1));
187+
assert!(((*(*(*from_lvalue.borrow()).t.borrow()).moves.borrow()) == 0));
188+
assert!(((*(*kept.borrow()).v.borrow()) == 11));
189+
let from_rvalue: Value<Holder> = Rc::new(RefCell::new(
190+
({
191+
let _x: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 12 })));
192+
forward_into_ctor_7(_x.as_pointer())
193+
}),
194+
));
195+
assert!(((*(*(*from_rvalue.borrow()).t.borrow()).v.borrow()) == 12));
196+
assert!(((*(*(*from_rvalue.borrow()).t.borrow()).copies.borrow()) == 0));
197+
assert!(((*(*(*from_rvalue.borrow()).t.borrow()).moves.borrow()) == 1));
198+
return 0;
199+
}
200+
pub fn __cpp2rust_init_globals() {}

‎tests/unit/out/refcount/forward_decltype.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -133,8 +133,8 @@ fn main_0() -> i32 {
133133
let c: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 7 })));
134134
assert!(
135135
(({
136-
let _args: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 8 })));
137-
forward_abbreviated_pack_6(c.as_pointer(), _args.as_pointer())
136+
let _args_1: Value<Tracked> = Rc::new(RefCell::new(Tracked::Tracked({ 8 })));
137+
forward_abbreviated_pack_6(c.as_pointer(), _args_1.as_pointer())
138138
}) == ((Overload_kLvalueOverload as i32) + (Overload_kRvalueOverload as i32)))
139139
);
140140
assert!(((*(*c.borrow()).v.borrow()) == 7));

‎tests/unit/out/unsafe/forward_basic.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ pub unsafe fn forward_into_ctor_6(x: *mut Tracked) -> Holder {
9191
return Holder::Holder1({ x });
9292
}
9393
pub unsafe fn forward_into_ctor_7(x: *mut Tracked) -> Holder {
94-
return (*x);
94+
return Holder::Holder2({ x });
9595
}
9696
pub fn main() {
9797
unsafe {

‎tests/unit/out/unsafe/forward_decltype.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -104,8 +104,8 @@ unsafe fn main_0() -> i32 {
104104
let mut c: Tracked = Tracked::Tracked({ 7 });
105105
assert!(
106106
((unsafe {
107-
let mut _args: Tracked = Tracked::Tracked({ 8 });
108-
forward_abbreviated_pack_6(&mut c, &mut _args)
107+
let mut _args_1: Tracked = Tracked::Tracked({ 8 });
108+
forward_abbreviated_pack_6(&mut c, &mut _args_1)
109109
}) == ((Overload_kLvalueOverload as i32) + (Overload_kRvalueOverload as i32)))
110110
);
111111
assert!(((c.v) == (7)));

‎tests/unit/out/unsafe/forward_pack.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -128,17 +128,17 @@ unsafe fn main_0() -> i32 {
128128
let mut i: i32 = 3;
129129
assert!(
130130
((unsafe {
131-
let mut _args: Tracked = Tracked::Tracked({ 4 });
132-
let mut _args: i32 = 5;
133-
forward_pack_7(&mut a, &mut _args, &mut i, &mut _args)
131+
let mut _args_1: Tracked = Tracked::Tracked({ 4 });
132+
let mut _args_3: i32 = 5;
133+
forward_pack_7(&mut a, &mut _args_1, &mut i, &mut _args_3)
134134
}) == (1234))
135135
);
136136
assert!(((a.v) == (1)));
137137
assert!(((i) == (3)));
138138
let mut lhs: Tracked = Tracked::Tracked({ 6 });
139139
let mut p: Pair = (unsafe {
140-
let mut _args: Tracked = Tracked::Tracked({ 7 });
141-
forward_pack_into_ctor_8(&mut lhs, &mut _args)
140+
let mut _args_1: Tracked = Tracked::Tracked({ 7 });
141+
forward_pack_into_ctor_8(&mut lhs, &mut _args_1)
142142
});
143143
assert!(((p.a.v) == (6)));
144144
assert!(((p.a.copies) == (1)));

0 commit comments

Comments
 (0)