structural_derive 0.4.3

Implementation detail of the structural crate.
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

use crate::ident_or_index::IdentOrIndexRef;

use proc_macro2::{Span, TokenStream as TokenStream2};

#[allow(unused_imports)]
use quote::{quote_spanned, ToTokens};

////////////////////////////////////////////////////////////////////////////////////////////

#[cfg(all(feature = "use_const_str", not(feature = "disable_const_str")))]
pub(crate) fn tstr_tokens<S>(string: S, span: Span) -> TokenStream2
where
    S: AsRef<str>,
{
    let string = string.as_ref();

    quote_spanned!(span=> ::structural::TStr<::structural::__TS<#string>> )
}

#[cfg(any(not(feature = "use_const_str"), feature = "disable_const_str"))]
/// Tokenizes a `TStr<>` in which each character is written as a type.
pub(crate) fn tstr_tokens<S>(string: S, span: Span) -> TokenStream2
where
    S: AsRef<str>,
{
    let mut buffer = String::with_capacity(6);
    let bytes = string.as_ref().bytes().map(move |b| {
        buffer.clear();
        let c = b as char;
        if (c.is_alphanumeric() || c == '_') && b < 128 {
            buffer.push_str("__");
            buffer.push(c);
        } else {
            buffer.push_str("__0x");
            write_hex(b / 16, &mut buffer);
            write_hex(b % 16, &mut buffer);
        }
        syn::Ident::new(&buffer, Span::call_site())
    });
    quote_spanned!(span=>
        ::structural::TStr<::structural::__TS<( #( ::structural::#bytes,)* )>>
    )
}

#[inline]
#[allow(dead_code)]
fn write_hex(mut n: u8, buffer: &mut String) {
    n &= 0xF;
    const HEX_OFFSET: u8 = b'A' - 10;
    let offset = if n < 10 { b'0' } else { HEX_OFFSET };
    buffer.push((n + offset) as char);
}

pub(crate) fn variant_field_tokens(
    variant: IdentOrIndexRef<'_>,
    field: IdentOrIndexRef<'_>,
) -> TokenStream2 {
    let variant_tokens = variant.tstr_tokens();
    let field_tokens = field.tstr_tokens();
    let span = field.span();
    quote_spanned!(span=>
        ::structural::pmr::VariantField<
            #variant_tokens,
            #field_tokens,
        >
    )
}

pub(crate) fn variant_name_tokens(variant: IdentOrIndexRef<'_>) -> TokenStream2 {
    let variant_tokens = variant.tstr_tokens();
    let span = variant.span();
    quote_spanned!(span=>
        ::structural::pmr::VariantName< #variant_tokens >
    )
}