kago-macros 0.4.0

A macros for Kago.
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

//! Kago-Core (籠コア)
//!
//! Kago で用いられる実装のマクロを提供する。

#![warn(
    missing_docs,
    rustdoc::missing_crate_level_docs,
    unused_results,
    clippy::complexity,
    clippy::perf,
    clippy::style
)]
#![deny(clippy::correctness, clippy::suspicious)]

mod bit_ops;
mod bounded;
mod core;
mod from;
mod num;
mod num_cast;
mod num_ops;
mod prim_int;
mod sign;

use proc_macro::TokenStream;
use proc_macro2::Span;
use quote::quote;
use std::ops::RangeInclusive;
use syn::Ident;

/// 実装
#[proc_macro]
pub fn limited_bits(tokens: TokenStream) -> TokenStream {
    limited_bits_impl(tokens.into(), 1..=128).into()
}

fn limited_bits_impl(
    _: proc_macro2::TokenStream,
    range: RangeInclusive<u32>,
) -> proc_macro2::TokenStream {
    let mut impls = Vec::new();
    for n in range.clone() {
        for is_signed in [false, true].iter() {
            let flag_name = core::feature_name(n, *is_signed);
            let module_name = Ident::new(format!("bit_{}", flag_name).as_str(), Span::call_site());
            let struct_name = core::struct_name(n, *is_signed);
            let ty = core::inner_type(n, *is_signed);
            let shift = core::shift(n);
            let masking = core::masking(&shift);
            let struct_impl = core::impl_struct(&struct_name, &ty, &shift);
            let debug_impl = core::impl_debug(&struct_name, &shift);
            let binary_impl = core::impl_binary(n, &struct_name, &shift);
            let add_impl = num_ops::impl_add(&struct_name);
            let sub_impl = num_ops::impl_sub(&struct_name);
            let mul_impl = num_ops::impl_mul(&struct_name, &shift);
            let div_impl = num_ops::impl_div(&struct_name, &shift);
            let rem_impl = num_ops::impl_rem(&struct_name);
            let checked_add_impl = num_ops::impl_checked_add(&struct_name);
            let checked_sub_impl = num_ops::impl_checked_sub(&struct_name);
            let checked_mul_impl = num_ops::impl_checked_mul(&struct_name, &ty, &shift);
            let checked_div_impl = num_ops::impl_checked_div(&struct_name, &ty, &shift);
            let checked_rem_impl = num_ops::impl_checked_rem(&struct_name, &ty);
            let saturating_impl = num_ops::impl_saturating(&struct_name, &ty, &masking);
            let zero_impl = num::impl_zero(&struct_name);
            let one_impl = num::impl_one(&struct_name);
            let num_impl = num::impl_num(&struct_name, &ty);
            let to_primitive_impl = num_cast::impl_to_primitive(&struct_name, &ty, &shift);
            let wrapping_add_impl = num_ops::impl_wrapping_add(&struct_name);
            let wrapping_sub_impl = num_ops::impl_wrapping_sub(&struct_name);
            let num_cast_impl = num_cast::impl_num_cast(&struct_name, &ty, &shift);
            let bounded_impl = bounded::impl_bounded(&struct_name, &ty, &shift);
            let not_impl = bit_ops::impl_not(&struct_name, &masking);
            let bitand_impl = bit_ops::impl_bitand(&struct_name, &masking);
            let bitor_impl = bit_ops::impl_bitor(&struct_name, &masking);
            let bitxor_impl = bit_ops::impl_bitxor(&struct_name, &masking);
            let shl_impl = bit_ops::impl_shl(&struct_name);
            let shr_impl = bit_ops::impl_shr(&struct_name, &masking);
            let prim_int_impl = prim_int::impl_prim_int(&struct_name, &ty, &shift, &masking);
            let sign_impl = sign::impl_sign(&struct_name, *is_signed);
            impls.push(quote! {
                #[cfg(feature = #flag_name)]
                pub use #module_name::#struct_name;

                #[cfg(feature = #flag_name)]
                mod #module_name {
                    #struct_impl
                    #debug_impl
                    #binary_impl
                    #add_impl
                    #checked_add_impl
                    #wrapping_add_impl
                    #sub_impl
                    #checked_sub_impl
                    #wrapping_sub_impl
                    #mul_impl
                    #checked_mul_impl
                    #div_impl
                    #checked_div_impl
                    #rem_impl
                    #checked_rem_impl
                    #saturating_impl
                    #zero_impl
                    #one_impl
                    #num_impl
                    #to_primitive_impl
                    #num_cast_impl
                    #bounded_impl
                    #not_impl
                    #bitand_impl
                    #bitor_impl
                    #bitxor_impl
                    #shl_impl
                    #shr_impl
                    #prim_int_impl
                    #sign_impl
                }
            });
        }
    }
    let from_impl = from::impl_from(&range);
    quote! {
        #(#impls)*
        #from_impl
    }
}