Skip to content

Commit ccf1160

Browse files
lucic71lucic71
committed
Update tests
1 parent 0cb3ff6 commit ccf1160

26 files changed

Lines changed: 584 additions & 979 deletions

‎tests/unit/lambda_capture_star_this.cpp‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
// no-compile: unsafe
21
#include <assert.h>
32

43
struct S {

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

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -27,11 +27,14 @@ fn main_0() -> i32 {
2727
assert!((({ apply_1(5, None,) }) == 5));
2828
assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::null()),) }) == 5));
2929
assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::new(identity_0)),) }) == 5));
30-
let negate: Value<FnPtr<fn(i32) -> i32>> =
31-
Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(|x: i32| {
32-
let x: Value<i32> = Rc::new(RefCell::new(x));
33-
return -(*x.borrow());
34-
})));
30+
let negate: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
31+
|x: i32| -> i32 {
32+
{
33+
let x: Value<i32> = Rc::new(RefCell::new(x));
34+
return -(*x.borrow());
35+
}
36+
},
37+
)));
3538
assert!((({ apply_1(5, Some((*negate.borrow()).clone()),) }) == -5_i32));
3639
return 0;
3740
}

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

Lines changed: 29 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -11,33 +11,44 @@ pub fn main() {
1111
std::process::exit(main_0());
1212
}
1313
fn main_0() -> i32 {
14-
let zero: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new(FnPtr::<fn() -> i32>::new(|| {
15-
return 42;
16-
})));
17-
assert!((({ (*zero.borrow()).call() }) == 42));
18-
let one: Value<FnPtr<fn(i32) -> i32>> =
19-
Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(|x: i32| {
20-
let x: Value<i32> = Rc::new(RefCell::new(x));
21-
return ((*x.borrow()) + 1);
14+
let zero: Value<FnPtr<fn() -> i32>> =
15+
Rc::new(RefCell::new(FnPtr::<fn() -> i32>::new(|| -> i32 {
16+
{
17+
return 42;
18+
}
2219
})));
20+
assert!((({ (*zero.borrow()).call() }) == 42));
21+
let one: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
22+
|x: i32| -> i32 {
23+
{
24+
let x: Value<i32> = Rc::new(RefCell::new(x));
25+
return ((*x.borrow()) + 1);
26+
}
27+
},
28+
)));
2329
assert!((({ (*one.borrow()).call(1,) }) == 2));
2430
let three: Value<FnPtr<fn(i32, i32, i32) -> i32>> =
2531
Rc::new(RefCell::new(FnPtr::<fn(i32, i32, i32) -> i32>::new(
26-
|x: i32, y: i32, z: i32| {
27-
let x: Value<i32> = Rc::new(RefCell::new(x));
28-
let y: Value<i32> = Rc::new(RefCell::new(y));
29-
let z: Value<i32> = Rc::new(RefCell::new(z));
30-
return ((((*x.borrow()) * 100) + ((*y.borrow()) * 10)) + (*z.borrow()));
32+
|x: i32, y: i32, z: i32| -> i32 {
33+
{
34+
let x: Value<i32> = Rc::new(RefCell::new(x));
35+
let y: Value<i32> = Rc::new(RefCell::new(y));
36+
let z: Value<i32> = Rc::new(RefCell::new(z));
37+
return ((((*x.borrow()) * 100) + ((*y.borrow()) * 10)) + (*z.borrow()));
38+
}
3139
},
3240
)));
3341
assert!((({ (*three.borrow()).call(1, 2, 3,) }) == 123));
3442
let k: Value<i32> = Rc::new(RefCell::new(3));
3543
let m: Value<i32> = Rc::new(RefCell::new(4));
36-
let constants: Value<FnPtr<fn(i32) -> i32>> =
37-
Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(|x: i32| {
38-
let x: Value<i32> = Rc::new(RefCell::new(x));
39-
return (((*x.borrow()) + 3) + 4);
40-
})));
44+
let constants: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(
45+
FnPtr::<fn(i32) -> i32>::new(|x: i32| -> i32 {
46+
{
47+
let x: Value<i32> = Rc::new(RefCell::new(x));
48+
return (((*x.borrow()) + 3) + 4);
49+
}
50+
}),
51+
));
4152
assert!((({ (*constants.borrow()).call(1,) }) == 8));
4253
return 0;
4354
}

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

Lines changed: 40 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -94,25 +94,14 @@ pub fn main() {
9494
}
9595
fn main_0() -> i32 {
9696
let c: Value<Counted> = Rc::new(RefCell::new(Counted::new()));
97-
let f: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new({
98-
#[derive(Record, ByteRepr)]
99-
#[byte_size(8)]
100-
struct Captures {
101-
#[offset(0)]
102-
#[byte_size(8)]
103-
c: Counted,
97+
let f: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new(lambda!(
98+
{
99+
let c: Value<Counted> = Rc::new(RefCell::new(Counted::copy_from({ c.as_pointer() })));
100+
},
101+
|| -> i32 {
102+
return (({ (*self.c.borrow()).copies } * 10) + { (*self.c.borrow()).moves });
104103
}
105-
FnPtr::<fn() -> i32>::with_captures(
106-
Captures {
107-
c: Counted::copy_from({ c.as_pointer() }),
108-
},
109-
(|this: Ptr<Captures>| {
110-
return (({ (*this.upgrade().deref()).c.copies } * 10) + {
111-
(*this.upgrade().deref()).c.moves
112-
});
113-
}),
114-
)
115-
}));
104+
)));
116105
assert!((({ (*f.borrow()).call() }) == 10));
117106
let g: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new((*f.borrow()).clone()));
118107
assert!((({ (*g.borrow()).call() }) == 20));
@@ -121,23 +110,15 @@ fn main_0() -> i32 {
121110
assert!((({ (*h.borrow()).call() }) == 11));
122111
let returned: Value<i32> = Rc::new(RefCell::new({
123112
({
124-
{
125-
#[derive(Record, ByteRepr)]
126-
#[byte_size(8)]
127-
struct Captures {
128-
#[offset(0)]
129-
#[byte_size(8)]
130-
c: Counted,
113+
lambda!(
114+
{
115+
let c: Value<Counted> =
116+
Rc::new(RefCell::new(Counted::copy_from({ c.as_pointer() })));
117+
},
118+
|| -> Counted {
119+
return Counted::copy_from({ self.c.as_pointer() });
131120
}
132-
FnPtr::<fn() -> Counted>::with_captures(
133-
Captures {
134-
c: Counted::copy_from({ c.as_pointer() }),
135-
},
136-
(|this: Ptr<Captures>| {
137-
return Counted::copy_from({ field_ptr!(this, c) });
138-
}),
139-
)
140-
}
121+
)
141122
.call()
142123
})
143124
.copies
@@ -146,57 +127,40 @@ fn main_0() -> i32 {
146127
let arr: Value<Box<[Counted]>> = Rc::new(RefCell::new(Box::new(
147128
std::array::from_fn::<_, 2, _>(|_| Counted::new()),
148129
)));
149-
let a: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new({
150-
#[derive(Record, ByteRepr)]
151-
#[byte_size(16)]
152-
struct Captures {
153-
#[offset(0)]
154-
#[byte_size(16)]
155-
arr: Value<Box<[Counted]>>,
130+
let a: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new(lambda!(
131+
{
132+
let arr: Value<Box<[Counted]>> = Rc::new(RefCell::new(Box::new(
133+
std::array::from_fn::<_, 2, _>(|__i: usize| {
134+
Counted::copy_from({ (arr.as_pointer() as Ptr<Counted>).offset(__i) })
135+
}),
136+
)));
137+
},
138+
|| -> i32 {
139+
return ({ (*self.arr.borrow())[(0) as usize].copies } + {
140+
(*self.arr.borrow())[(1) as usize].copies
141+
});
156142
}
157-
FnPtr::<fn() -> i32>::with_captures(
158-
Captures {
159-
arr: Rc::new(RefCell::new(Box::new(std::array::from_fn::<_, 2, _>(
160-
|__i: usize| {
161-
Counted::copy_from({ (arr.as_pointer() as Ptr<Counted>).offset(__i) })
162-
},
163-
)))),
164-
},
165-
(|this: Ptr<Captures>| {
166-
return ({ (*this.with(|__s| __s.arr.clone()).borrow())[(0) as usize].copies } + {
167-
(*this.with(|__s| __s.arr.clone()).borrow())[(1) as usize].copies
168-
});
169-
}),
170-
)
171-
}));
143+
)));
172144
assert!((({ (*a.borrow()).call() }) == 2));
173145
let a2: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new((*a.borrow()).clone()));
174146
assert!((({ (*a2.borrow()).call() }) == 4));
175147
{
176-
let m: Value<FnPtr<fn()>> = Rc::new(RefCell::new({
177-
#[derive(Record, ByteRepr)]
178-
#[byte_size(1)]
179-
struct Captures {
180-
#[offset(0)]
181-
#[byte_size(1)]
182-
d: Dropped,
183-
}
184-
FnPtr::<fn()>::with_captures(Captures { d: Dropped::new() }, (|this: Ptr<Captures>| {}))
185-
}));
148+
let m: Value<FnPtr<fn()>> = Rc::new(RefCell::new(lambda!(
149+
{
150+
let d: Value<Dropped> = Rc::new(RefCell::new(Dropped::new()));
151+
},
152+
|| {}
153+
)));
186154
let m2: Value<FnPtr<fn()>> = Rc::new(RefCell::new((*m.borrow_mut()).clone()));
187155
}
188156
assert!((drops_0.with(|rc| *rc.borrow()) == 2));
189157
{
190-
let k: Value<FnPtr<fn()>> = Rc::new(RefCell::new({
191-
#[derive(Record, ByteRepr)]
192-
#[byte_size(1)]
193-
struct Captures {
194-
#[offset(0)]
195-
#[byte_size(1)]
196-
d: Dropped,
197-
}
198-
FnPtr::<fn()>::with_captures(Captures { d: Dropped::new() }, (|this: Ptr<Captures>| {}))
199-
}));
158+
let k: Value<FnPtr<fn()>> = Rc::new(RefCell::new(lambda!(
159+
{
160+
let d: Value<Dropped> = Rc::new(RefCell::new(Dropped::new()));
161+
},
162+
|| {}
163+
)));
200164
let k2: Value<FnPtr<fn()>> = Rc::new(RefCell::new((*k.borrow()).clone()));
201165
}
202166
assert!((drops_0.with(|rc| *rc.borrow()) == 4));

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

Lines changed: 35 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -14,95 +14,50 @@ fn main_0() -> i32 {
1414
let a: Value<i32> = Rc::new(RefCell::new(1));
1515
let b: Value<i32> = Rc::new(RefCell::new(2));
1616
let c: Value<i32> = Rc::new(RefCell::new(3));
17-
let by_value: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new({
18-
#[derive(Record, ByteRepr)]
19-
#[byte_size(12)]
20-
struct Captures {
21-
#[offset(0)]
22-
a: i32,
23-
#[offset(4)]
24-
b: i32,
25-
#[offset(8)]
26-
c: i32,
17+
let by_value: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
18+
{
19+
let a: Value<i32> = Rc::new(RefCell::new((*a.borrow())));
20+
let b: Value<i32> = Rc::new(RefCell::new((*b.borrow())));
21+
let c: Value<i32> = Rc::new(RefCell::new((*c.borrow())));
22+
},
23+
|x: i32| -> i32 {
24+
let x: Value<i32> = Rc::new(RefCell::new(x));
25+
return ((((*self.a.borrow()) + (*self.b.borrow())) + (*self.c.borrow()))
26+
+ (*x.borrow()));
2727
}
28-
FnPtr::<fn(i32) -> i32>::with_captures(
29-
Captures {
30-
a: (*a.borrow()),
31-
b: (*b.borrow()),
32-
c: (*c.borrow()),
33-
},
34-
(|this: Ptr<Captures>, x: i32| {
35-
let x: Value<i32> = Rc::new(RefCell::new(x));
36-
return (((this.with(|__s| __s.a) + this.with(|__s| __s.b))
37-
+ this.with(|__s| __s.c))
38-
+ (*x.borrow()));
39-
}),
40-
)
41-
}));
28+
)));
4229
assert!((({ (*by_value.borrow()).call(10,) }) == 16));
4330
(*a.borrow_mut()) = 100;
4431
assert!((({ (*by_value.borrow()).call(10,) }) == 16));
45-
let by_ref: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new({
46-
#[derive(Record, ByteRepr)]
47-
#[byte_size(24)]
48-
struct Captures {
49-
#[offset(0)]
50-
#[byte_size(8)]
51-
a: Ptr<i32>,
52-
#[offset(8)]
53-
#[byte_size(8)]
54-
b: Ptr<i32>,
55-
#[offset(16)]
56-
#[byte_size(8)]
57-
c: Ptr<i32>,
32+
let by_ref: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
33+
{
34+
let a: Ptr<i32> = a.as_pointer();
35+
let b: Ptr<i32> = b.as_pointer();
36+
let c: Ptr<i32> = c.as_pointer();
37+
},
38+
|x: i32| -> i32 {
39+
let x: Value<i32> = Rc::new(RefCell::new(x));
40+
return ((((self.a.read()) + (self.b.read())) + (self.c.read())) + (*x.borrow()));
5841
}
59-
FnPtr::<fn(i32) -> i32>::with_captures(
60-
Captures {
61-
a: a.as_pointer(),
62-
b: b.as_pointer(),
63-
c: c.as_pointer(),
64-
},
65-
(|this: Ptr<Captures>, x: i32| {
66-
let x: Value<i32> = Rc::new(RefCell::new(x));
67-
return ((((this.with(|__s| __s.a.clone()).read())
68-
+ (this.with(|__s| __s.b.clone()).read()))
69-
+ (this.with(|__s| __s.c.clone()).read()))
70-
+ (*x.borrow()));
71-
}),
72-
)
73-
}));
42+
)));
7443
assert!((({ (*by_ref.borrow()).call(10,) }) == 115));
7544
(*b.borrow_mut()) = 200;
7645
assert!((({ (*by_ref.borrow()).call(10,) }) == 313));
77-
let mixed: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new({
78-
#[derive(Record, ByteRepr)]
79-
#[byte_size(16)]
80-
struct Captures {
81-
#[offset(0)]
82-
#[byte_size(8)]
83-
c: Ptr<i32>,
84-
#[offset(8)]
85-
a: i32,
86-
#[offset(12)]
87-
b: i32,
46+
let mixed: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
47+
{
48+
let c: Ptr<i32> = c.as_pointer();
49+
let a: Value<i32> = Rc::new(RefCell::new((*a.borrow())));
50+
let b: Value<i32> = Rc::new(RefCell::new((*b.borrow())));
51+
},
52+
|x: i32| -> i32 {
53+
let x: Value<i32> = Rc::new(RefCell::new(x));
54+
{
55+
let _ptr = self.c.clone();
56+
_ptr.write(_ptr.read() + (*x.borrow()))
57+
};
58+
return (((*self.a.borrow()) + (*self.b.borrow())) + (self.c.read()));
8859
}
89-
FnPtr::<fn(i32) -> i32>::with_captures(
90-
Captures {
91-
c: c.as_pointer(),
92-
a: (*a.borrow()),
93-
b: (*b.borrow()),
94-
},
95-
(|this: Ptr<Captures>, x: i32| {
96-
let x: Value<i32> = Rc::new(RefCell::new(x));
97-
{
98-
let _ptr = this.with(|__s| __s.c.clone()).clone();
99-
_ptr.write(_ptr.read() + (*x.borrow()))
100-
};
101-
return ((this.with(|__s| __s.a) + this.with(|__s| __s.b))
102-
+ (this.with(|__s| __s.c.clone()).read()));
103-
}),
104-
)
105-
}));
60+
)));
10661
assert!((({ (*mixed.borrow()).call(1,) }) == ((100 + 200) + 4)));
10762
assert!(((*c.borrow()) == 4));
10863
return 0;

0 commit comments

Comments
 (0)