architect-derive 0.4.0

use proc_macro::TokenStream;

mod derive_from_inner;
mod derive_from_str_json;
mod derive_from_value;
mod derive_newtype;
mod derive_try_into_any_inner;
mod enum_factory;

// CR alee: move into netidx and add attr netidx_repr, to specify your choice of Bytes
// (default) or some other Value type
/// Derives `Into<Value>` and `From<Value>` from `netidx` for the given type.
///
/// Specifically, this macro derives `Into<netidx::protocol::value::Value>` and
/// `From<netidx::protocol::value::Value>` for the given type.  The type must implement
/// `netidx_core::pack::Pack` and the derived implementation will encode/decode the type as a
/// `netidx::protocol::value::Value::Bytes`.
#[proc_macro_derive(FromValue)]
pub fn derive_from_value(input: TokenStream) -> TokenStream {
    derive_from_value::derive_from_value(input)
}

/// Given an enum whose variants are all singular tuples, derive `From<InnerType>` for each
/// variant's inner type.
///
/// For example, given the following enum:
///
/// ```rust,ignore
/// #[derive(FromInner)]
/// enum Foo {
///     Ayy(A),
///     Bae(B),
/// }
/// ```
///
/// The following impls will be generated:
///
/// ```rust,ignore
/// impl From<A> for Foo { /* ... */ }
/// impl From<B> for Foo { /* ... */ }
/// ```
///
/// such that
///
/// ```rust,ignore
/// let a: A = /* ... */;
/// let b: B = /* ... */;
/// assert_eq!(Foo::from(a), Foo::Ayy(a));
/// assert_eq!(Foo::from(b), Foo::Bae(b));
/// ```
///
/// Each variant's inner type must be distinct, otherwise the macro expansion will produce
/// conflicting impls, which presents as a compilation error.
#[proc_macro_derive(FromInner)]
pub fn derive_from_inner(input: TokenStream) -> TokenStream {
    derive_from_inner::derive_from_inner(input)
}

/// Given an enum whose variants are all singular tuples, derive
/// `Enum: TryInto<MaybeSplit<Enum, Inner>>` for each variant's inner type.
///
/// Each variant's inner type must be distinct, otherwise the macro expansion will
/// produce conflicting impls, which presents as a compilation error.
#[proc_macro_derive(TryIntoAnyInner, attributes(transitive))]
pub fn derive_try_into_any_inner(input: TokenStream) -> TokenStream {
    derive_try_into_any_inner::derive_try_into_any_inner(input)
}

#[proc_macro_derive(Newtype, attributes(newtype))]
pub fn derive_newtype(input: TokenStream) -> TokenStream {
    derive_newtype::derive_newtype(input)
}

#[proc_macro_attribute]
pub fn enum_factory(args: TokenStream, input: TokenStream) -> TokenStream {
    enum_factory::enum_factory(args, input)
}

#[proc_macro_derive(FromStrJson)]
pub fn derive_from_str_json(input: TokenStream) -> TokenStream {
    derive_from_str_json::derive_from_str_json(input)
}

#[proc_macro_attribute]
pub fn grpc(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // NB alee: just an indicator for the tonic build script
    item
}