typ 0.1.1

Type-level programming in Rust
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

use super::*;

pub fn translate_impl(impl_: &ItemImpl) -> syn::Result<TokenStream> {
    let ItemImpl {
        defaultness,
        unsafety,
        generics,
        trait_,
        self_ty,
        items,
        ..
    } = impl_;

    // sanity check
    if let Some(defaultness) = defaultness {
        return Err(Error::new(
            defaultness.span(),
            "default keyword is not supported",
        ));
    }
    if let Some(unsafety) = unsafety {
        return Err(Error::new(
            unsafety.span(),
            "unsafe keyword is not supported",
        ));
    }
    if trait_.is_some() {
        return Err(Error::new(
            impl_.span(),
            r#""for Trait" clause is not supported"#,
        ));
    }

    let items_tokens: Vec<_> = items
        .iter()
        .map(|item| -> syn::Result<_> {
            let tokens = match item {
                ImplItem::Method(method) => {
                    let ImplItemMethod {
                        sig, block, vis, ..
                    } = method;
                    translate_fn(vis, sig, block, Some(&**self_ty), Some(generics))?
                }
                _ => {
                    return Err(Error::new(item.span(), "unsupported item"));
                }
            };

            Ok(tokens)
        })
        .try_collect()?;

    let expanded = quote! { #(#items_tokens)* };
    Ok(expanded)
}