summaryrefslogtreecommitdiffstats
path: root/vendor/proc-macro2/tests/marker.rs
blob: 4fb2beb8e94ee66190361c657ab72cf3c16b20cc (plain)
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
use proc_macro2::{
    Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
};

macro_rules! assert_impl {
    ($ty:ident is $($marker:ident) and +) => {
        #[test]
        #[allow(non_snake_case)]
        fn $ty() {
            fn assert_implemented<T: $($marker +)+>() {}
            assert_implemented::<$ty>();
        }
    };

    ($ty:ident is not $($marker:ident) or +) => {
        #[test]
        #[allow(non_snake_case)]
        fn $ty() {
            $(
                {
                    // Implemented for types that implement $marker.
                    trait IsNotImplemented {
                        fn assert_not_implemented() {}
                    }
                    impl<T: $marker> IsNotImplemented for T {}

                    // Implemented for the type being tested.
                    trait IsImplemented {
                        fn assert_not_implemented() {}
                    }
                    impl IsImplemented for $ty {}

                    // If $ty does not implement $marker, there is no ambiguity
                    // in the following trait method call.
                    <$ty>::assert_not_implemented();
                }
            )+
        }
    };
}

assert_impl!(Delimiter is Send and Sync);
assert_impl!(Spacing is Send and Sync);

assert_impl!(Group is not Send or Sync);
assert_impl!(Ident is not Send or Sync);
assert_impl!(LexError is not Send or Sync);
assert_impl!(Literal is not Send or Sync);
assert_impl!(Punct is not Send or Sync);
assert_impl!(Span is not Send or Sync);
assert_impl!(TokenStream is not Send or Sync);
assert_impl!(TokenTree is not Send or Sync);

#[cfg(procmacro2_semver_exempt)]
mod semver_exempt {
    use proc_macro2::{LineColumn, SourceFile};

    assert_impl!(LineColumn is Send and Sync);

    assert_impl!(SourceFile is not Send or Sync);
}

#[cfg(not(no_libprocmacro_unwind_safe))]
mod unwind_safe {
    use proc_macro2::{
        Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
    };
    #[cfg(procmacro2_semver_exempt)]
    use proc_macro2::{LineColumn, SourceFile};
    use std::panic::{RefUnwindSafe, UnwindSafe};

    macro_rules! assert_unwind_safe {
        ($($types:ident)*) => {
            $(
                assert_impl!($types is UnwindSafe and RefUnwindSafe);
            )*
        };
    }

    assert_unwind_safe! {
        Delimiter
        Group
        Ident
        LexError
        Literal
        Punct
        Spacing
        Span
        TokenStream
        TokenTree
    }

    #[cfg(procmacro2_semver_exempt)]
    assert_unwind_safe! {
        LineColumn
        SourceFile
    }
}