cvlr-asserts 0.6.1

Asserts and assumes for post- and pre-conditions
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

#[rustfmt::skip]
macro_rules! impl_bin_assert {
    ($name: ident, $pred: tt, $dollar: tt) => {
        #[macro_export]
        macro_rules! $name {
        ($lhs: expr, $rhs: expr $dollar(, $desc: literal)? ) => {{
            let __cvlr_lhs = $lhs;
            let __cvlr_rhs = $rhs;
            cvlr::log::log_scope_start("assert");
            cvlr::clog!(stringify!($lhs $pred $rhs) => "_");
            cvlr::clog!(__cvlr_lhs => stringify!($lhs));
            cvlr::clog!(__cvlr_rhs => stringify!($rhs));
            cvlr::log::log_scope_end("assert");
            $crate::cvlr_assert!(__cvlr_lhs $pred __cvlr_rhs);
        }};
    }
        pub use $name;
    };
}

impl_bin_assert!(cvlr_assert_eq, ==, $);
impl_bin_assert!(cvlr_assert_ne, !=, $);
impl_bin_assert!(cvlr_assert_le, <=, $);
impl_bin_assert!(cvlr_assert_lt, <, $);
impl_bin_assert!(cvlr_assert_ge, >=, $);
impl_bin_assert!(cvlr_assert_gt, >, $);

#[rustfmt::skip]
macro_rules! impl_bin_assume {
    ($name: ident, $pred: tt, $dollar: tt) => {
        #[macro_export]
        macro_rules! $name {
        ($lhs: expr, $rhs: expr $dollar(, $desc: literal)? ) => {{
            let __cvlr_lhs = $lhs;
            let __cvlr_rhs = $rhs;
            cvlr::log::log_scope_start("assume");
            cvlr::clog!(stringify!($lhs $pred $rhs) => "_");
            cvlr::clog!(__cvlr_lhs => stringify!($lhs));
            cvlr::clog!(__cvlr_rhs => stringify!($rhs));
            cvlr::log::log_scope_end("assume");
            $crate::cvlr_assume!(__cvlr_lhs $pred __cvlr_rhs);
        }};
    }
        pub use $name;
    };
}

impl_bin_assume!(cvlr_assume_eq, ==, $);
impl_bin_assume!(cvlr_assume_ne, !=, $);
impl_bin_assume!(cvlr_assume_le, <=, $);
impl_bin_assume!(cvlr_assume_lt, <, $);
impl_bin_assume!(cvlr_assume_ge, >=, $);
impl_bin_assume!(cvlr_assume_gt, >, $);

#[macro_export]
macro_rules! cvlr_assert_if {
    ($guard: expr, $cond: expr) => {
        if $guard {
            $crate::cvlr_assert!($cond);
        }
    };
}

#[rustfmt::skip]
macro_rules! impl_bin_assert_if {
    ($name: ident, $pred: tt, $dollar: tt) => {
        #[macro_export]
        macro_rules! $name {
        ($guard: expr,$lhs: expr, $rhs: expr $dollar(, $desc: literal)? ) => {{
            let __cvlr_guard = $guard;
            cvlr::clog!(stringify!(assert if $guard { $lhs $pred $rhs }) => "_");
            cvlr::clog!(__cvlr_guard => stringify!($guard));
            if __cvlr_guard {
                let __cvlr_lhs = $lhs;
                let __cvlr_rhs = $rhs;
                cvlr::clog!(__cvlr_lhs => stringify!($lhs));
                cvlr::clog!(__cvlr_rhs => stringify!($rhs));
                $crate::cvlr_assert!(__cvlr_lhs $pred __cvlr_rhs);
            }
        }};
    }
        pub use $name;
    };
}

impl_bin_assert_if!(cvlr_assert_eq_if, ==, $);
impl_bin_assert_if!(cvlr_assert_ne_if, !=, $);
impl_bin_assert_if!(cvlr_assert_le_if, <=, $);
impl_bin_assert_if!(cvlr_assert_lt_if, <, $);
impl_bin_assert_if!(cvlr_assert_ge_if, >=, $);
impl_bin_assert_if!(cvlr_assert_gt_if, >, $);