typeslice-macros 0.1.2

type-level slices
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

use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse_macro_input, LitByte, LitByteStr, LitChar, LitStr};

#[proc_macro]
pub fn from_str(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let item = parse_macro_input!(item as Option<LitStr>);
    expand_chars(item)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

#[proc_macro]
pub fn from_bytes(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let item = parse_macro_input!(item as Option<LitByteStr>);
    expand_bytes(item)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

#[proc_macro]
pub fn utf8(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let item = parse_macro_input!(item as Option<LitStr>);
    expand_utf8(item)
        .unwrap_or_else(syn::Error::into_compile_error)
        .into()
}

enum Chars {
    Cons(LitChar, Box<Self>),
    Nil,
}

impl ToTokens for Chars {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        tokens.extend(match self {
            Chars::Cons(c, rest) => quote!(::typeslice::types::Char<#c, #rest>),
            Chars::Nil => quote!(::typeslice::types::CharNil),
        })
    }
}

fn expand_chars(lit: Option<LitStr>) -> syn::Result<TokenStream> {
    let root = match lit {
        Some(it) => it.value().chars().rev().fold(Chars::Nil, |acc, el| {
            Chars::Cons(LitChar::new(el, it.span()), Box::new(acc))
        }),
        None => Chars::Nil,
    };
    Ok(root.into_token_stream())
}

fn expand_utf8(lit: Option<LitStr>) -> syn::Result<TokenStream> {
    let root = match lit {
        Some(it) => it.value().bytes().rev().fold(Bytes::Nil, |acc, el| {
            Bytes::Cons(LitByte::new(el, it.span()), Box::new(acc))
        }),
        None => Bytes::Nil,
    };
    Ok(root.into_token_stream())
}

enum Bytes {
    Cons(LitByte, Box<Self>),
    Nil,
}

impl ToTokens for Bytes {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        tokens.extend(match self {
            Bytes::Cons(b, rest) => quote!(::typeslice::types::U8<#b, #rest>),
            Bytes::Nil => quote!(::typeslice::types::U8Nil),
        })
    }
}

fn expand_bytes(lit: Option<LitByteStr>) -> syn::Result<TokenStream> {
    let root = match lit {
        Some(it) => it.value().into_iter().rev().fold(Bytes::Nil, |acc, el| {
            Bytes::Cons(LitByte::new(el, it.span()), Box::new(acc))
        }),
        None => Bytes::Nil,
    };
    Ok(root.into_token_stream())
}