use quote::quote;
use crate::{
interface::{InterfaceField, InterfaceModel},
union::UnionMember,
};
impl InterfaceModel {
pub(crate) fn contract(&self) -> proc_macro2::TokenStream {
let fields = self.fields_trait();
let derivations = self.derivations_trait();
let ties = self.members.iter().map(|member| self.ties(member));
let members = self.members.iter().map(|member| self.member_impl(member));
let delegation = self.delegating_impl();
quote! {
#fields
#derivations
const _: () = {
#(#ties)*
#(#members)*
#delegation
};
}
}
fn fields_trait(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let name = self.fields_name();
let interface = &self.name;
let doc = format!(
"What every member of [`{interface}`] carries.\n\nOne method per STORED field of the \
declaration's contract. A member's own implementation is field access, so a member missing a \
column is refused at the column and a member holding another type is refused at its \
type.\n\nComputed fields are NOT here: a derived value is answered from the wire output \
rather than from a row, and [`{derivations}`] is the face that carries them.",
derivations = self.derivations_name()
);
let methods = self.stored().map(|field| {
let signature = self.signature(field);
let doc = format!("The `{}` field of this [`{interface}`].", field.name);
quote! {
#[doc = #doc]
#signature;
}
});
quote! {
#[doc = #doc]
#vis trait #name {
#(#methods)*
}
}
}
fn derivations_trait(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let name = self.derivations_name();
let interface = &self.name;
let doc = format!(
"What every member of [`{interface}`] DERIVES.\n\nOne method per computed field of the \
declaration's contract, returning an owned value because a derivation produces rather than \
holds.\n\nImplemented BY HAND, on the members' wire OUTPUT types — a derived value is \
answered from the output rather than from a row, so the type that owes these methods is \
`<<M as Transformer>::Graphql as Graphql>::Output` for each member `M`. Nothing generates \
one: an author writing a derivation writes their own glue, so there is no adapter under this \
trait."
);
let methods = self.computed().map(|field| {
let signature = self.signature(field);
let doc = format!(
"The `{}` value this [`{interface}`] member derives.",
field.name
);
let errors = field.tier.fallible().then(|| {
let refusal = format!(
"# Errors\n[`{error}`] — whatever the implementor refuses with, which the declaration \
named at `graphql(computed(error = \"…\"))`.",
error = tight(&self.computed_error())
);
quote!(#[doc = ""] #[doc = #refusal])
});
quote! {
#[doc = #doc]
#errors
#signature;
}
});
quote! {
#[doc = #doc]
#vis trait #name {
#(#methods)*
}
}
}
fn signature(&self, field: &InterfaceField) -> proc_macro2::TokenStream {
let name = &field.name;
let ty = &field.ty;
if field.tier.fallible() {
let error = self.computed_error();
return quote!(fn #name(&self) -> ::core::result::Result<#ty, #error>);
}
if field.tier.computed() {
return quote!(fn #name(&self) -> #ty);
}
if field.copy {
return quote!(fn #name(&self) -> #ty);
}
if is_string(ty) {
return quote!(fn #name(&self) -> &::core::primitive::str);
}
quote!(fn #name(&self) -> &#ty)
}
fn ties(&self, member: &UnionMember) -> proc_macro2::TokenStream {
let interface = &self.name;
let ty = &member.ty;
let implements = self.framework(&["transform"], "implements");
let stores_rows = self.framework(&["transform"], "stores_rows");
let wire = self.framework(&["transform"], "has_a_wire_face");
quote! {
const _: fn() = #implements::<#ty, #interface>;
const _: fn() = #stores_rows::<#ty>;
const _: fn() = #wire::<#ty>;
}
}
fn member_impl(&self, member: &UnionMember) -> proc_macro2::TokenStream {
let name = self.fields_name();
let ty = &member.ty;
let methods = self.stored().map(|field| {
let at = field.name.span();
let signature = self.signature(field);
let column = field.column(&member.ident);
let body = if field.copy {
quote::quote_spanned!(at=> self.#column)
} else {
quote::quote_spanned!(at=> &self.#column)
};
quote::quote_spanned! {at=>
#[inline]
#signature {
#body
}
}
});
quote! {
#[automatically_derived]
impl #name for #ty {
#(#methods)*
}
}
}
fn delegating_impl(&self) -> proc_macro2::TokenStream {
let name = self.fields_name();
let interface = &self.name;
let methods = self.stored().map(|field| {
let signature = self.signature(field);
let column = &field.name;
let arms = self.members.iter().map(|member| {
let variant = &member.ident;
let ty = &member.ty;
quote!(Self::#variant(member) => <#ty as #name>::#column(member),)
});
quote! {
#[inline]
#signature {
match self { #(#arms)* }
}
}
});
quote! {
#[automatically_derived]
impl #name for #interface {
#(#methods)*
}
}
}
}
fn is_string(ty: &syn::Type) -> bool {
let syn::Type::Path(path) = ty else {
return false;
};
path.qself.is_none()
&& path.path.segments.len() == 1
&& path
.path
.segments
.last()
.is_some_and(|segment| segment.ident == "String" && segment.arguments.is_none())
}
pub(super) fn tight(tokens: &proc_macro2::TokenStream) -> String {
tokens.to_string().replace(' ', "")
}