admiral-derive 0.1.0

Procedural macro for Admiral test runner
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

use std::collections::HashSet;

use proc_macro::TokenStream;
use proc_macro2::{Ident, Span};
use quote::{quote_spanned, ToTokens};
use syn::{
    parse::{Parse, ParseStream},
    punctuated::Punctuated,
    spanned::Spanned,
    Error, ItemFn, Token,
};

struct Args {
    _vars: HashSet<Ident>,
}

impl Parse for Args {
    fn parse(input: ParseStream) -> Result<Self, Error> {
        let vars = Punctuated::<Ident, Token![,]>::parse_terminated(input)?;
        Ok(Args {
            _vars: vars.into_iter().collect(),
        })
    }
}

fn async_to_sync(mut input: syn::ItemFn) -> Result<ItemFn, Error> {
    if input.sig.asyncness.take().is_none() {
        let msg = "the `async` keyword is missing from the function declaration";
        return Err(syn::Error::new_spanned(input.sig.fn_token, msg));
    }
    let (last_stmt_start_span, last_stmt_end_span) = {
        let mut last_stmt = input
            .block
            .stmts
            .last()
            .map(ToTokens::into_token_stream)
            .unwrap_or_default()
            .into_iter();
        // `Span` on stable Rust has a limitation that only points to the first
        // token, not the whole tokens. We can work around this limitation by
        // using the first/last span of the tokens like
        // `syn::Error::new_spanned` does.
        let start = last_stmt.next().map_or_else(Span::call_site, |t| t.span());
        let end = last_stmt.last().map_or(start, |t| t.span());
        (start, end)
    };

    let body = &input.block;
    let brace_token = input.block.brace_token;
    input.block = syn::parse2(quote_spanned! {last_stmt_end_span=>
        {
            futures::executor::block_on(async #body);
        }
    })
    .expect("Parsing failure");
    input.block.brace_token = brace_token;
    Ok(input)
}

#[proc_macro_attribute]
pub fn rust_decorator_fn(args: TokenStream, input: TokenStream) -> TokenStream {
    let mut func: ItemFn = syn::parse(input).unwrap();
    let mut func = async_to_sync(func).unwrap();
    let ident = &func.sig.ident;
    let test_path = syn::LitStr::new(&format!("::{}", ident), proc_macro2::Span::call_site());
    let mut allow_fail = false;
    let mut ignore = false;
    func.attrs.retain(|ref attr| {
        match attr.path.clone().into_token_stream().to_string().as_ref() {
            "allow_fail" => allow_fail = true,
            "ignore" => ignore = true,
            _ => return true,
        }
        false
    });

    let x = func.clone().block;

    let func_span = func.span();
    let res = quote_spanned!(func_span=>
        #[allow(dead_code,non_upper_case_globals)]
        #[test_case]
        pub const #ident:  admiral_types::RussTestDescAndFn =  admiral_types::RussTestDescAndFn {
            desc: rustc_test::TestDesc {
                allow_fail: #allow_fail,
                ignore: #ignore,
                should_panic: rustc_test::ShouldPanic::Yes,
                name: rustc_test::StaticTestName(concat!(module_path!(), #test_path)),
            },
            testfn: || {
                #x
            },
        };
    );
    res.into()
}