1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
//! null pointer optimization with iota-reduction for enums.
//!
//! Iota-reduction is a rule from the Calculus of (Co-)Inductive Constructions:
//! "a destructor applied to an object built from a constructor behaves as expected".
//! See <https://coq.inria.fr/doc/language/core/conversion.html#iota-reduction>.
//!
//! This test verifies that null pointer optimization works correctly for both
//! Option<T> and custom enums, accounting for pointers and regions.
//@ run-pass
#![allow(unpredictable_function_pointer_comparisons)]
enum E<T> {
Thing(isize, T),
#[allow(dead_code)]
Nothing((), ((), ()), [i8; 0]),
}
impl<T> E<T> {
fn is_none(&self) -> bool {
match *self {
E::Thing(..) => false,
E::Nothing(..) => true,
}
}
fn get_ref(&self) -> (isize, &T) {
match *self {
E::Nothing(..) => panic!("E::get_ref(Nothing::<{}>)", stringify!(T)),
E::Thing(x, ref y) => (x, y),
}
}
}
macro_rules! check_option {
($e:expr, $T:ty) => {{
check_option!($e, $T, |ptr| assert_eq!(*ptr, $e));
}};
($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
assert!(None::<$T>.is_none());
let e = $e;
let s_ = Some::<$T>(e);
let $v = s_.as_ref().unwrap();
$chk
}};
}
macro_rules! check_fancy {
($e:expr, $T:ty) => {{
check_fancy!($e, $T, |ptr| assert_eq!(*ptr, $e));
}};
($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
assert!(E::Nothing::<$T>((), ((), ()), [23; 0]).is_none());
let e = $e;
let t_ = E::Thing::<$T>(23, e);
match t_.get_ref() {
(23, $v) => $chk,
_ => panic!("Thing::<{}>(23, {}).get_ref() != (23, _)", stringify!($T), stringify!($e)),
}
}};
}
macro_rules! check_type {
($($a:tt)*) => {{
check_option!($($a)*);
check_fancy!($($a)*);
}}
}
pub fn main() {
check_type!(&17, &isize);
check_type!(Box::new(18), Box<isize>);
check_type!("foo".to_string(), String);
check_type!(vec![20, 22], Vec<isize>);
check_type!(main, fn(), |pthing| assert_eq!(main as fn(), *pthing as fn()));
}
|
