conferencier-derive 0.0.2

Procedural macro derive for ConferModule
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use proc_macro2::{Span, TokenStream};
use syn::Ident;

/// Intermediate representation of a module annotated with `#[derive(ConferModule)]`.
#[derive(Debug, Clone)]
pub struct Module {
    pub ident: Ident,
    pub generics: syn::Generics,
    pub section: String,
    pub fields: Vec<Field>,
}

/// Description of a single field within a derived module.
#[derive(Debug, Clone)]
pub struct Field {
    pub ident: Ident,
    pub key: String,
    pub kind: Option<FieldType>,
    pub default: Option<TokenStream>,
    pub init: Option<TokenStream>,
    pub ignore: bool,
    pub span: Span,
}

/// Fully classified field type, including container and scalar information.
#[derive(Debug, Clone)]
pub struct FieldType {
    pub container: ContainerKind,
    pub scalar: ScalarKind,
}

/// High-level container category for a field (plain, option, vector, etc.).
#[derive(Debug, Clone, Copy)]
pub enum ContainerKind {
    Plain,
    Vec,
    Option,
    OptionVec,
}

/// Primitive scalar type available for derived configuration fields.
#[derive(Debug, Clone)]
pub enum ScalarKind {
    String,
    Bool,
    Integer(IntegerKind),
    Float(FloatKind),
    Datetime,
}

/// Supported integer widths mapped from TOML values.
#[derive(Debug, Clone, Copy)]
pub enum IntegerKind {
    I8,
    I16,
    I32,
    I64,
    Isize,
    U8,
    U16,
    U32,
    U64,
    Usize,
}

/// Supported floating-point widths mapped from TOML values.
#[derive(Debug, Clone, Copy)]
pub enum FloatKind {
    F32,
    F64,
}

impl IntegerKind {
    /// Returns the Rust type tokens for the integer variant.
    pub fn type_tokens(&self) -> TokenStream {
        match self {
            Self::I8 => quote::quote!(i8),
            Self::I16 => quote::quote!(i16),
            Self::I32 => quote::quote!(i32),
            Self::I64 => quote::quote!(i64),
            Self::Isize => quote::quote!(isize),
            Self::U8 => quote::quote!(u8),
            Self::U16 => quote::quote!(u16),
            Self::U32 => quote::quote!(u32),
            Self::U64 => quote::quote!(u64),
            Self::Usize => quote::quote!(usize),
        }
    }
}

impl FloatKind {
    /// Returns the Rust type tokens for the floating-point variant.
    pub fn type_tokens(&self) -> TokenStream {
        match self {
            Self::F32 => quote::quote!(f32),
            Self::F64 => quote::quote!(f64),
        }
    }
}