kermit-derive 0.0.7

Kermit derive macros
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

//! Procedural macros for the Kermit workspace.
//!
//! Provides `#[derive(IntoTrieIter)]` to automatically implement
//! [`IntoIterator`] for trie-iterator types, wrapping them in
//! `TrieIteratorWrapper` so that `for tuple in iter { ... }` yields
//! `Vec<usize>` tuples directly.
//!
//! # Example
//!
//! ```ignore
//! use kermit_iters::{LinearIterator, TrieIterator, TrieIteratorWrapper};
//! use kermit_derive::IntoTrieIter;
//!
//! #[derive(IntoTrieIter)]
//! struct MyTrieIter<'a> {
//!     // ... fields ...
//! }
//!
//! impl LinearIterator for MyTrieIter<'_> { /* ... */ }
//! impl TrieIterator   for MyTrieIter<'_> { /* ... */ }
//!
//! // The derive generates:
//! //   impl<'a> IntoIterator for MyTrieIter<'a> {
//! //       type Item = Vec<usize>;
//! //       type IntoIter = TrieIteratorWrapper<Self>;
//! //       fn into_iter(self) -> Self::IntoIter { TrieIteratorWrapper::new(self) }
//! //   }
//! ```
//!
//! See `kermit-derive/tests/derive_into_trie_iter.rs` for a runnable example
//! with a minimal mock trie, and `kermit-ds` for two production uses
//! (`TreeTrieIter`, `ColumnTrieIter`).

#![deny(missing_docs)]

use {
    proc_macro::TokenStream,
    quote::quote,
    syn::{parse_macro_input, DeriveInput, GenericParam},
};

/// Derives [`IntoIterator`] for a trie-iterator struct.
///
/// The annotated struct must:
/// - implement `kermit_iters::TrieIterator` (and therefore
///   `kermit_iters::LinearIterator`),
/// - have exactly one generic parameter, and it must be a lifetime named `'a`.
///
/// The expanded impl wraps `self` in a `kermit_iters::TrieIteratorWrapper`,
/// yielding each root-to-leaf path in the trie as a `Vec<usize>`.
#[proc_macro_derive(IntoTrieIter)]
pub fn derive_into_trie_iter(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let ident = &input.ident;

    let params: Vec<_> = input.generics.params.iter().collect();
    let valid =
        matches!(params.as_slice(), [GenericParam::Lifetime(lt)] if lt.lifetime.ident == "a");
    if !valid {
        let msg = format!(
            "#[derive(IntoTrieIter)] requires exactly one generic parameter, a lifetime named \
             `'a`; found {} parameter(s) on `{}`",
            params.len(),
            ident
        );
        return quote! { compile_error!(#msg); }.into();
    }

    let output = quote! {

        impl<'a> IntoIterator for #ident<'a> {
            type Item = Vec<usize>;
            type IntoIter = TrieIteratorWrapper<Self>;

            fn into_iter(self) -> Self::IntoIter {
                TrieIteratorWrapper::new(self)
            }
        }

    };

    output.into()
}