remote-trait-object-macro 0.4.1

Macro that expands a Rust trait to a remote-trait-object service
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

pub fn path_of_single_ident(ident: syn::Ident) -> syn::Path {
    syn::Path {
        leading_colon: None,
        segments: {
            let mut punc = syn::punctuated::Punctuated::new();
            punc.push(syn::PathSegment {
                ident,
                arguments: syn::PathArguments::None,
            });
            punc
        },
    }
}

/// In addition, it coverts str->String and [] -> Vec
pub fn is_ref(the_type: &syn::Type) -> Result<Option<syn::Type>, String> {
    if *the_type
        == syn::parse2::<syn::Type>(quote! {
            &str
        })
        .unwrap()
    {
        return Ok(Some(
            syn::parse2::<syn::Type>(quote! {
                String
            })
            .unwrap(),
        ))
    }

    match the_type {
        syn::Type::Reference(x) => {
            if x.lifetime.is_some() {
                return Err("Lifetime exists".to_owned())
            }
            if x.mutability.is_some() {
                return Err("Mutable".to_owned())
            }
            match *x.elem {
                syn::Type::Slice(_) => Ok(Some(
                    syn::parse2::<syn::Type>(quote! {
                        Vec<_>
                    })
                    .unwrap(),
                )),
                _ => Ok(Some((*x.elem).clone())),
            }
        }
        _ => Ok(None),
    }
}

#[test]
fn recognize_ref() {
    let t = syn::parse_str::<syn::Type>("Vec<u32>").unwrap();
    assert!(is_ref(&t).unwrap().is_none());
    let t = syn::parse_str::<syn::Type>("&Vec<u32>").unwrap();
    let tu = syn::parse_str::<syn::Type>("Vec<u32>").unwrap();
    assert_eq!(is_ref(&t).unwrap().unwrap(), tu);
    let t = syn::parse_str::<syn::Type>("&i32").unwrap();
    let tu = syn::parse_str::<syn::Type>("i32").unwrap();
    assert_eq!(is_ref(&t).unwrap().unwrap(), tu);
    let t = syn::parse_str::<syn::Type>("&str").unwrap();
    let tu = syn::parse_str::<syn::Type>("String").unwrap();
    assert_eq!(is_ref(&t).unwrap().unwrap(), tu);
    let t = syn::parse_str::<syn::Type>("&[u8]").unwrap();
    let tu = syn::parse_str::<syn::Type>("Vec<_>").unwrap();
    assert_eq!(is_ref(&t).unwrap().unwrap(), tu);
    let t = syn::parse_str::<syn::Type>("&mut i32").unwrap();
    assert!(is_ref(&t).is_err())
}