newnum_proc_macros 0.13.1

Procedural macros reexported by the deprecated `newnum` crate
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

use derive_syn_parse::Parse;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{parse_macro_input, Lit, Token};

pub fn num(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    num_macro_helper(
        "from_int_literal",
        "from_float_literal",
        quote! { ::newnum },
        input,
    )
}

pub fn num_approx(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    num_macro_helper(
        "approx_from_int_literal",
        "approx_from_float_literal",
        quote! { ::newnum },
        input,
    )
}

pub fn internal_num(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    num_macro_helper(
        "from_int_literal",
        "from_float_literal",
        quote! { crate },
        input,
    )
}

pub fn internal_num_approx(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    num_macro_helper(
        "approx_from_int_literal",
        "approx_from_float_literal",
        quote! { crate },
        input,
    )
}

fn num_macro_helper(
    int_fn_ident: &str,
    float_fn_ident: &str,
    crate_path: TokenStream,
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    #[derive(Parse)]
    struct Input {
        neg: Option<Token![-]>,
        literal: Lit,
        #[prefix(Option<Token![:]> as punct)]
        #[parse_if(punct.is_some())]
        ty: Option<TokenStream>,
    }

    let Input { neg, literal, ty } = parse_macro_input!(input as Input);

    let (literal_ty, from_trait, from_fn) = if let Lit::Float(_) = literal {
        (quote! { f64 }, quote! { FromFloatLiteral }, float_fn_ident)
    } else {
        (quote! { i128 }, quote! { FromIntLiteral }, int_fn_ident)
    };

    let from_fn = format_ident!("{from_fn}");
    let ty = ty.unwrap_or_else(|| quote! { _});

    quote! {
        {
            const MACRO_INPUT: #literal_ty = #neg #literal;

            {
                fn num_macro_fn<NumMacroType: #crate_path::#from_trait>() -> NumMacroType {
                    if const {
                        if MACRO_INPUT < <NumMacroType as #crate_path::FromIntLiteral>::MIN_LITERAL as #literal_ty {
                            panic!("literal out of range")
                        }

                        if MACRO_INPUT > <NumMacroType as #crate_path::FromIntLiteral>::MAX_LITERAL as #literal_ty {
                            panic!("literal out of range")
                        }

                        true
                    } {
                        unsafe { <NumMacroType as #crate_path::#from_trait>::#from_fn(MACRO_INPUT) }
                    } else {
                        unreachable!()
                    }
                }

                num_macro_fn::<#ty>()
            }
        }
    }
    .into()
}