syn_args/macro_args/
utils.rs

1use std::collections::HashMap;
2
3use quote::ToTokens;
4use syn::Error;
5
6use super::{def, Value};
7
8pub fn otr<T>(opt: Option<T>) -> Result<T, Error> {
9    match opt {
10        Some(val) => Ok(val),
11        None => Err(Error::new(proc_macro2::Span::call_site(), "Invalid args otr")),
12    }
13}
14
15pub fn ewc<F, T, E>(callback: F) -> Result<T, E>
16where
17    F: FnOnce() -> Result<T, E>,
18{
19    // 调用闭包并返回结果
20    callback()
21}
22
23pub(crate) fn recursive_parsing(input: &syn::Expr) -> Value {
24    match input {
25        syn::Expr::Lit(lit) => recursive_lit(&lit.lit),
26        syn::Expr::Array(array) => {
27            let mut arr = vec![];
28            for item in array.elems.iter() {
29                let item = recursive_parsing(item);
30                arr.push(item);
31            }
32            Value::Array(def::Array(arr))
33        }
34        syn::Expr::Struct(struct_expr) => {
35            let mut obj = HashMap::new();
36            for field in struct_expr.fields.iter() {
37                let key = field.member.to_token_stream().to_string();
38                let value = recursive_parsing(&field.expr);
39                obj.insert(key, value);
40            }
41            Value::Object(def::Object(obj))
42        }
43        _ => Value::Expr(def::Expr(input.clone())),
44    }
45}
46
47pub(crate) fn recursive_lit(lit: &syn::Lit) -> Value {
48    match lit {
49        syn::Lit::Int(int) => {
50            let v = int.base10_parse::<i32>().unwrap();
51            Value::Int(def::Int(v))
52        }
53        syn::Lit::Str(str) => {
54            let v = str.value();
55            Value::String(def::String(v))
56        }
57        syn::Lit::Float(float) => {
58            let v = float.base10_parse::<f32>().unwrap();
59            Value::Float(def::Float(v))
60        }
61        syn::Lit::Bool(bool) => {
62            let v = bool.value;
63            Value::Bool(def::Bool(v))
64        }
65        _ => Value::Null,
66    }
67}