narrative-macros 0.12.0

Procedural macros for the narrative 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

mod error;
mod extract_types_for_assertion;
mod item_story;
mod local_type_for;
mod no_foreign_type_validation;
mod output;
mod step_attr_syntax;
mod step_usage;
mod story_attr_syntax;

use item_story::ItemStory;
use proc_macro2::TokenStream;
use story_attr_syntax::StoryAttr;
use syn::parse_macro_input;

#[proc_macro_attribute]
/// TODO: Add documentation.
pub fn story(
    attr: proc_macro::TokenStream,
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let attr = parse_macro_input!(attr as StoryAttr);
    let story = parse_macro_input!(input as ItemStory);
    process_story(attr, story).into()
}

#[proc_macro_attribute]
/// Marks a data type as a local type for a specific story.
/// This implements both `IndependentType` and `<StoryName>LocalType` for the type.
pub fn local_type_for(
    attr: proc_macro::TokenStream,
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let story_name = parse_macro_input!(attr as syn::Ident);
    let input_item = parse_macro_input!(input as syn::Item);

    local_type_for::generate(&story_name, &input_item).into()
}

// In general, we don't do caching some intermediate results to keep the implementation simple.
// However, we should avoid to have heavy computation in this crate, to keep the story compilation
// fast. So, modules have their own functionality which is simple.
fn process_story(attr: StoryAttr, story: ItemStory) -> TokenStream {
    output::generate(&attr, &story)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Asyncness {
    Sync,
    Async,
}

impl quote::ToTokens for Asyncness {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        match self {
            Asyncness::Sync => quote::quote!().to_tokens(tokens),
            Asyncness::Async => quote::quote!(async).to_tokens(tokens),
        }
    }
}

pub(crate) fn collect_format_args(lit_str: &syn::LitStr) -> Vec<String> {
    lit_str
        .value()
        // remove escaped braces
        .split("{{")
        .flat_map(|part| part.split("}}"))
        // iter parts that start with '{' by skipping the first split
        .flat_map(|part| part.split('{').skip(1))
        // take the part before the first '}'
        .filter_map(|part| part.split_once('}').map(|(head, _)| head))
        // remove parts after the first ':'
        .map(|format| {
            format
                .split_once(':')
                .map(|(head, _)| head)
                .unwrap_or(format)
        })
        .map(ToOwned::to_owned)
        .collect()
}

struct MakeStaticWalker;

impl syn::visit_mut::VisitMut for MakeStaticWalker {
    fn visit_type_reference_mut(&mut self, i: &mut syn::TypeReference) {
        i.lifetime = Some(syn::Lifetime::new(
            "'static",
            proc_macro2::Span::mixed_site(),
        ));
        self.visit_type_mut(&mut i.elem);
    }
}

pub(crate) fn make_static(ty: &syn::Type) -> syn::Type {
    use syn::visit_mut::VisitMut;
    let mut walker = MakeStaticWalker;
    let mut static_ty = ty.clone();
    walker.visit_type_mut(&mut static_ty);
    static_ty
}

pub(crate) fn pretty_print_expr(expr: &syn::Expr) -> String {
    prettyplease::unparse(
        &syn::parse_file(
            &quote::quote! {
                const IDENT: String = #expr;
            }
            .to_string(),
        )
        .unwrap(),
    )
    .replace("const IDENT: String = ", "")
    .replace(";", "")
    .trim()
    .to_string()
}

pub(crate) fn pretty_print_type(ty: &syn::Type) -> String {
    prettyplease::unparse(
        &syn::parse_file(
            &quote::quote! {
                const IDENT: #ty = 1;
            }
            .to_string(),
        )
        .unwrap(),
    )
    .replace("const IDENT: ", "")
    .replace(" = 1;", "")
    .trim()
    .to_string()
}