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

// Copyright 2018-2019 Cryptape Technologies LLC.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use proc_macro2::{Span, TokenStream};
use quote::ToTokens;

macro_rules! parse_attr_with_check {
    (Int, $key:ident, $input:ident, $output:ident) => {
        $output.$key = $input.base10_digits().parse().unwrap();
    };
    (Bool, $key:ident, $input:ident, $output:ident) => {
        $output.$key = $input.value;
    };
    ($lit_type:ident, $key:ident, $input:expr, $output:ident, $check:ident) => {{
        if $check.contains(stringify!($key)) {
            panic!(
                "Error because attribute `{}` has been set more than once",
                stringify!($key)
            );
        }
        $check.insert(stringify!($key));
        let parse_is_ok = if let syn::Lit::$lit_type(ref value) = $input {
            parse_attr_with_check!($lit_type, $key, value, $output);
            true
        } else {
            false
        };
        if !parse_is_ok {
            let value = $input;
            panic!(
                "Failed to parse attribute `{}`(={})",
                stringify!($key),
                quote!(#value)
            );
        }
    }};
}

/// Get a nonnegative integer literal without type.
pub fn pure_uint_to_ts(val: u64) -> TokenStream {
    syn::LitInt::new(&val.to_string(), Span::call_site()).into_token_stream()
}

/// Get a built-in nonnegative integer type.
pub fn uint_suffix_to_ts(val: u64) -> TokenStream {
    match val {
        8 | 16 | 32 | 64 | 128 => ident_to_ts(format!("u{}", val).as_ref()),
        _ => unreachable!(),
    }
}

/// Get a ident from a string.
pub fn ident_to_ts(val: &str) -> TokenStream {
    syn::Ident::new(val, Span::call_site()).into_token_stream()
}

/// Get a list of nonnegative integer literals without type.
pub fn pure_uint_list_to_ts<T>(vals: T) -> Vec<TokenStream>
where
    T: Iterator<Item = u64>,
{
    vals.map(pure_uint_to_ts).collect()
}