pliron-derive 0.18.0

Derive macros for pliron
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) The pliron contributors

//! Derive macro for `Verify` trait that always succeeds.

pub(crate) fn verify_succ_impl(
    args: proc_macro2::TokenStream,
    input: proc_macro2::TokenStream,
) -> syn::Result<proc_macro2::TokenStream> {
    if !args.is_empty() {
        return Err(syn::Error::new_spanned(
            args,
            "verify_succ does not accept any arguments",
        ));
    }

    let item = syn::parse2::<syn::Item>(input)?;
    match &item {
        syn::Item::Struct(item_struct) => {
            let ident = &item_struct.ident;
            let (impl_generics, ty_generics, where_clause) = item_struct.generics.split_for_impl();
            Ok(quote::quote! {
                #item

                impl #impl_generics ::pliron::common_traits::Verify for #ident #ty_generics #where_clause {
                    fn verify(&self, _ctx: &::pliron::context::Context) -> ::pliron::result::Result<()> {
                        Ok(())
                    }
                }
            })
        }
        syn::Item::Enum(item_enum) => {
            let ident = &item_enum.ident;
            let (impl_generics, ty_generics, where_clause) = item_enum.generics.split_for_impl();
            Ok(quote::quote! {
                #item

                impl #impl_generics ::pliron::common_traits::Verify for #ident #ty_generics #where_clause {
                    fn verify(&self, _ctx: &::pliron::context::Context) -> ::pliron::result::Result<()> {
                        Ok(())
                    }
                }
            })
        }
        _ => Err(syn::Error::new_spanned(
            item,
            "verify_succ can only be applied to a struct or enum",
        )),
    }
}

#[cfg(test)]
mod tests {
    use super::verify_succ_impl;
    use expect_test::expect;
    use quote::quote;

    #[test]
    fn verify_succ_on_generic_struct() {
        let input = quote! {
            struct Wrapper<T>
            where
                T: Clone,
            {
                value: T,
            }
        };
        let result = verify_succ_impl(proc_macro2::TokenStream::new(), input).unwrap();
        let file = syn::parse2::<syn::File>(result).unwrap();
        let got = prettyplease::unparse(&file);

        expect![[r##"
            struct Wrapper<T>
            where
                T: Clone,
            {
                value: T,
            }
            impl<T> ::pliron::common_traits::Verify for Wrapper<T>
            where
                T: Clone,
            {
                fn verify(&self, _ctx: &::pliron::context::Context) -> ::pliron::result::Result<()> {
                    Ok(())
                }
            }
        "##]]
        .assert_eq(&got);
    }

    #[test]
    fn verify_succ_rejects_non_empty_arguments() {
        let result = verify_succ_impl(
            quote!(unused),
            quote!(
                struct Wrapper;
            ),
        );
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("verify_succ does not accept any arguments")
        );
    }
}