pessimize 3.0.2

More efficient Rust compiler optimization barriers
Documentation 
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Implementations of Pessimize for core::ops

use crate::{pessimize_extractible, pessimize_zsts, Pessimize};
use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};

// Requiring a Clone bound because all useful Range indices are Clone
pessimize_extractible!(
    allow(missing_docs)
    {
        (Idx, Idx): (
            |Idx: (Clone, Pessimize)| Range<Idx> : (
                |Self { start, end }| (start, end),
                |(start, end)| Self { start, end },
                |self_: &Self| (self_.start.clone(), self_.end.clone())
            ),
            |Idx: (Clone, Pessimize)| RangeInclusive<Idx> : (
                |self_: Self| (self_.start().clone(), self_.end().clone()),
                |(start, end)| Self::new(start, end),
                |self_: &Self| (self_.start().clone(), self_.end().clone())
            )
        ),
        Idx: (
            |Idx: (Clone, Pessimize)| RangeFrom<Idx> : (
                |Self { start }| start,
                |start| Self { start },
                |self_: &Self| self_.start.clone()
            ),
            |Idx: (Clone, Pessimize)| RangeTo<Idx> : (
                |Self { end }| end,
                |end| Self { end },
                |self_: &Self| self_.end.clone()
            ),
            |Idx: (Clone, Pessimize)| RangeToInclusive<Idx> : (
                |Self { end }| end,
                |end| Self { end },
                |self_: &Self| self_.end.clone()
            )
        )
    }
);
//
pessimize_zsts!(
    allow(missing_docs)
    {
        RangeFull: RangeFull
    }
);

#[cfg(test)]
mod tests {
    use crate::tests::{test_unoptimized_value, test_value};

    #[test]
    fn range() {
        test_value(isize::MIN..isize::MAX)
    }

    #[test]
    #[ignore]
    fn range_optim() {
        test_unoptimized_value(isize::MIN..isize::MAX)
    }

    #[test]
    fn range_inclusive() {
        test_value(usize::MIN..=usize::MAX)
    }

    #[test]
    #[ignore]
    fn range_inclusive_optim() {
        test_unoptimized_value(usize::MIN..=usize::MAX)
    }

    #[test]
    fn range_from() {
        test_value(i32::MIN..)
    }

    #[test]
    #[ignore]
    fn range_from_optim() {
        test_unoptimized_value(i32::MIN..)
    }

    #[test]
    fn range_to() {
        test_value(..u32::MAX)
    }

    #[test]
    #[ignore]
    fn range_to_optim() {
        test_unoptimized_value(..u32::MAX)
    }

    #[test]
    fn range_to_inclusive() {
        test_value(..=i16::MAX)
    }

    #[test]
    #[ignore]
    fn range_to_inclusive_optim() {
        test_unoptimized_value(..=i16::MAX)
    }

    #[test]
    fn range_full() {
        test_value(..)
    }

    // There is no range_full_optim test because Pessimize does not act as an
    // optimization barrier for stateless ZSTs like RangeFull
}