//! This crate provides derive macros used for the EosVariant and

//! FunctionalVariant enums in FeOs. The macros implement

//! the boilerplate for the EquationOfState and HelmholtzEnergyFunctional traits.

use components::expand_components;

use dft::expand_helmholtz_energy_functional;

use ideal_gas::expand_ideal_gas;

use proc_macro::TokenStream;

use residual::expand_residual;

use syn::{parse_macro_input, DeriveInput};

mod components;

mod dft;

mod ideal_gas;

mod residual;

fn implement(name: &str, variant: &syn::Variant, opts: &[&'static str]) -> syn::Result<bool> {

let syn::Variant { attrs, .. } = variant;

let mut implement = Ok(false);

for attr in attrs.iter() {

if attr.path.is_ident("implement") {

if let Ok(syn::Meta::List(list)) = attr.parse_meta() {

for meta in list.nested {

if let syn::NestedMeta::Meta(syn::Meta::Path(path)) = meta {

// check if all keywords are valid, return error if not

if !opts.iter().any(|s| path.is_ident(s)) {

let opts = opts.join(", ");

return Err(syn::Error::new_spanned(

path,

format!("expected one of: {}", opts),

));

}

// "name" is present

if path.is_ident(name) {

implement = Ok(true)

}

}

}

} else {

return Err(syn::Error::new_spanned(

&attr.tokens,

"expected 'implement(optional_trait, ...)'",

));

}

}

}

implement

}

#[proc_macro_derive(Components)]

pub fn derive_components(input: TokenStream) -> TokenStream {

let input = parse_macro_input!(input as DeriveInput);

expand_components(input)

.unwrap_or_else(syn::Error::into_compile_error)

.into()

}

#[proc_macro_derive(IdealGas)]

pub fn derive_ideal_gas(input: TokenStream) -> TokenStream {

let input = parse_macro_input!(input as DeriveInput);

expand_ideal_gas(input)

.unwrap_or_else(syn::Error::into_compile_error)

.into()

}

#[proc_macro_derive(Residual, attributes(implement))]

pub fn derive_residual(input: TokenStream) -> TokenStream {

let input = parse_macro_input!(input as DeriveInput);

expand_residual(input)

.unwrap_or_else(syn::Error::into_compile_error)

.into()

}

#[proc_macro_derive(HelmholtzEnergyFunctional, attributes(implement))]

pub fn derive_helmholtz_energy_functional(input: TokenStream) -> TokenStream {

let input = parse_macro_input!(input as DeriveInput);

expand_helmholtz_energy_functional(input)

.unwrap_or_else(syn::Error::into_compile_error)

.into()

}