qualifier_attr 0.2.2

Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! A test for every supported item.
//! This test requires the nightly toolchain to compile.

#![allow(dead_code, unused_imports, unused_macros)]
#![feature(extern_types, specialization, trait_alias)]

#[macro_use]
extern crate qualifier_attr;

#[qualifiers(pub)]
mod outer {
    // testing "common" items first...

    // const
    #[qualifiers(pub)]
    const ITEM_CONST: &str = "item const!";

    trait TraitItemConst {
        const IMPL_ITEM_CONST: &'static str;
    }

    struct ImplItemConst;

    impl TraitItemConst for ImplItemConst {
        #[qualifiers(default)]
        const IMPL_ITEM_CONST: &'static str = "impl item const!";
    }

    // fn
    #[qualifiers(pub, const, unsafe, extern "C")]
    fn item_fn_const() {}

    #[qualifiers(pub, async, unsafe, extern "C")]
    fn item_fn_async() {}

    extern "C" {
        #[qualifiers(pub)]
        fn foreign_item_fn();
    }

    trait TraitItemFn {
        #[qualifiers(unsafe, extern "C")]
        fn impl_item_fn();
    }

    struct ImplItemFn;

    impl TraitItemFn for ImplItemFn {
        #[qualifiers(default, unsafe, extern "C")]
        fn impl_item_fn() {}
    }

    // static
    #[qualifiers(pub)]
    static ITEM_STATIC: &str = "item static!";

    extern "C" {
        #[qualifiers(pub)]
        static FOREIGN_ITEM_STATIC: *const u8;
    }

    // type
    #[qualifiers(pub)]
    type ItemType<T> = [T; 2];

    extern "C" {
        #[qualifiers(pub)]
        type ForeignItemType;
    }

    trait TraitItemType {
        type ImplItemType<T: 'static>: 'static
        where
            T: TraitItemFn;
    }

    struct ImplItemType;

    impl TraitItemType for ImplItemType {
        #[qualifiers(default)]
        type ImplItemType<T: 'static> = ImplItemFn where T: TraitItemFn;
    }

    // other items...

    // enum
    #[qualifiers(pub)]
    enum ItemEnum {
        A,
        B,
        C,
    }

    // extern crate
    #[qualifiers(pub)]
    extern crate qualifier_attr as item_extern_crate;

    // (foreign mod supports unsafe syntactically but it does not compile)
    extern "C" {}

    // impl
    unsafe trait ItemImpl {}

    #[qualifiers(default, unsafe)]
    impl<T> ItemImpl for T {}

    // (macros have no support)
    macro_rules! item_macro {
        () => {};
    }

    // mod (supports unsafe syntactically but it does not compile)
    #[qualifiers(pub)]
    mod item_mod {}

    // struct
    #[qualifiers(pub)]
    struct ItemStruct {
        pub x: i32,
        pub y: i32,
    }

    // trait
    #[qualifiers(pub, unsafe)]
    trait ItemTrait {}

    unsafe impl ItemTrait for () {}

    // trait alias
    #[qualifiers(pub)]
    trait ItemTraitAlias = ItemTrait;

    // union
    #[qualifiers(pub)]
    union ItemUnion {
        pub x: i32,
        pub y: i32,
    }
}

mod export {
    #[qualifiers(pub)]
    use super::outer::{
        foreign_item_fn, item_extern_crate, item_fn_async, item_fn_const, item_mod,
        ForeignItemType, ItemEnum, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion,
        FOREIGN_ITEM_STATIC, ITEM_CONST, ITEM_STATIC,
    };
}

use export::{
    foreign_item_fn, item_extern_crate, item_fn_async, item_fn_const, item_mod, ForeignItemType,
    ItemEnum, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, FOREIGN_ITEM_STATIC,
    ITEM_CONST, ITEM_STATIC,
};