konst_macro_rules/
utils.rs

1#[doc(hidden)]
2#[repr(C)]
3pub union Dereference<'a, T: ?Sized> {
4    pub ptr: *const T,
5    pub reff: &'a T,
6}
7
8#[cfg(feature = "mut_refs")]
9mod mut_refs {
10    use core::mem::ManuallyDrop;
11
12    #[doc(hidden)]
13    #[repr(C)]
14    pub(crate) union BorrowMut<'a, T: ?Sized> {
15        ptr: *mut T,
16        reff: ManuallyDrop<&'a mut T>,
17    }
18
19    pub(crate) const unsafe fn deref_raw_mut_ptr<'a, T: ?Sized>(ptr: *mut T) -> &'a mut T {
20        ManuallyDrop::into_inner(BorrowMut { ptr }.reff)
21    }
22}
23
24#[track_caller]
25pub const fn panic(msg: &str) -> ! {
26    #[cfg(feature = "rust_1_57")]
27    {
28        panic!("{}", msg)
29    }
30    #[cfg(not(feature = "rust_1_57"))]
31    #[allow(unconditional_panic)]
32    {
33        [][0]
34    }
35}
36
37macro_rules! make_parse_closure_macro {
38    ($_:tt $macro_name:ident $arg_count:tt ($($pat_var:ident)*)) => {
39        #[doc(hidden)]
40        #[macro_export]
41        macro_rules! $macro_name {
42            (
43                $macro:tt $args:tt $usage_site:tt,
44                |$_($pat_var_:pat),* $_(,)?|  $_(,)?
45            ) => {
46                $crate::__parse_closure_no_expr_error!{$usage_site}
47            };
48            (
49                ($_($macro:tt)*) ($_($args:tt)*)
50                $usage_site:tt,
51                |$($_$pat_var:pat),* $_(,)?| $v:expr $_(,)*
52            ) => {
53                $_($macro)* ! {
54                    $_($args)*
55                    |$($_$pat_var),*| $v
56                }
57            };
58            (
59                $macro:tt $args:tt $usage_site:tt,
60                |$_($pat_var_:pat),* $_(,)?| $v:expr,
61                $trailing_expr:expr $_(, $_($rem:tt)*)?
62            ) => {
63                $crate::__parse_closure_trailing_expr_error!{$usage_site}
64            };
65            ($macro:tt $args:tt $usage_site:tt, | $_($anything:tt)* ) => {
66                $crate::__parse_closure_emit_error!{
67                    $arg_count
68                    $usage_site
69                }
70            };
71            ($macro:tt $args:tt $usage_site:tt, || $_($anything:tt)* ) => {
72                $crate::__parse_closure_emit_error!{
73                    $arg_count
74                    $usage_site
75                }
76            };
77            (
78                ($_($macro:tt)*) ($_($args:tt)*)
79                $usage_site:tt, $v:expr $_(,)?
80            ) => {
81                match $v {func => {
82                    $_($macro)* ! {
83                        $_($args)*
84                        |$($pat_var),*| func($($pat_var),*)
85                    }
86                }}
87            };
88            ($macro:tt $args:tt $usage_site:tt $_($rem:tt)*) => {
89                $crate::__parse_closure_emit_error!{
90                    $arg_count
91                    $usage_site
92                }
93            };
94
95            ( $_($anything:tt)* ) => {
96                $crate::__::compile_error!("expected a closure argument")
97            };
98        }
99
100        pub use $macro_name;
101    }
102}
103
104make_parse_closure_macro! { $ __parse_closure_1 1 (aaa) }
105make_parse_closure_macro! { $ __parse_closure_2 2 (aaa bbb) }
106
107#[doc(hidden)]
108#[macro_export]
109macro_rules! __parse_closure_no_expr_error {
110    (($($usage_site:tt)*)) => {
111        $crate::__::compile_error!{$crate::__::concat!(
112            "`",
113            $crate::__::stringify!($($usage_site)*),
114            "` expects valid closure syntax, passed closure without return value",
115        )}
116    };
117}
118
119#[doc(hidden)]
120#[macro_export]
121macro_rules! __parse_closure_trailing_expr_error {
122    (($($usage_site:tt)*)) => {
123        $crate::__::compile_error!{$crate::__::concat!(
124            "`",
125            $crate::__::stringify!($($usage_site)*),
126            "` expects no arguments after closure argument",
127        )}
128    };
129}
130
131#[doc(hidden)]
132#[macro_export]
133macro_rules! __parse_closure_emit_error {
134    ($count:tt ($($usage_site:tt)*)) => {
135        $crate::__::compile_error!{$crate::__::concat!(
136            "`",
137            $crate::__::stringify!($($usage_site)*),
138            "` expects to be passed a ",
139            $count,
140            "-parameter closure",
141        )}
142    };
143}
144
145#[cfg(feature = "mut_refs")]
146pub(crate) use mut_refs::{deref_raw_mut_ptr, BorrowMut};