use quote::quote;
use crate::{method::Member, name::RustSafeName};
pub mod wire;
pub struct UnitHeader<'a> {
pub vis: &'a syn::Visibility,
pub name: syn::Ident,
pub subject: String,
pub note: Option<String>,
}
impl UnitHeader<'_> {
fn doc(&self, sentence: &str) -> String {
crate::emit::leading(¬ed(sentence, self.note.as_deref()))
}
}
fn noted(sentence: &str, note: Option<&str>) -> String {
match note {
Some(note) => format!("{sentence}\n\n{note}"),
None => sentence.to_owned(),
}
}
pub struct FilterColumn {
pub member: syn::Ident,
pub name: String,
pub filter: proc_macro2::TokenStream,
pub gate: proc_macro2::TokenStream,
}
pub struct ComparisonColumn {
pub member: syn::Ident,
pub name: String,
pub held: proc_macro2::TokenStream,
pub gate: proc_macro2::TokenStream,
}
pub struct OrderColumn {
pub variant: syn::Ident,
pub name: String,
pub identity: String,
pub note: Option<String>,
pub gate: proc_macro2::TokenStream,
}
impl OrderColumn {
pub fn of(member: &syn::Ident, name: String) -> Self {
Self {
variant: crate::emit::upper_camel(&member.to_string()),
name,
identity: RustSafeName::from_ident(member).external().to_owned(),
note: None,
gate: proc_macro2::TokenStream::new(),
}
}
#[must_use]
pub fn with_note(mut self, note: String) -> Self {
self.note = Some(note);
self
}
#[must_use]
pub fn with_gate(mut self, gate: proc_macro2::TokenStream) -> Self {
self.gate = gate;
self
}
}
pub fn filter(
header: &UnitHeader<'_>,
columns: &[FilterColumn],
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let (vis, name, subject) = (&header.vis, &header.name, &header.subject);
let substrate = crate::emit::substrate();
let fields = columns.iter().map(|column| {
let (member, filter, gate) = (&column.member, &column.filter, &column.gate);
quote!(#gate #substrate #member: ::core::option::Option<#filter>,)
});
let doc = header.doc(&format!(
"A predicate over the stored columns of a {subject} — each field its type's FILTER, so a client \
may ask for any shape the framework's filters offer rather than equality alone."
));
let declaration = quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::default::Default)]
#vis struct #name {
#(#fields)*
}
};
let builders = columns.iter().map(|column| {
let (member, filter, gate) = (&column.member, &column.filter, &column.gate);
let with = Member::With.name(member);
let borrow = Member::Borrow.name(member);
let doc = crate::emit::leading(&format!(
"The same predicate with a filter on the {}.",
column.name
));
let borrow_doc = crate::emit::leading(&format!("The filter on the {}, if any.", column.name));
quote! {
#gate
#[doc = #doc]
#[must_use]
#[inline]
#vis fn #with(mut self, filter: #filter) -> Self {
self.#member = ::core::option::Option::Some(filter);
self
}
#gate
#[doc = #borrow_doc]
#[inline]
#vis const fn #borrow(&self) -> ::core::option::Option<&#filter> {
self.#member.as_ref()
}
}
});
(
declaration,
quote! {
impl #name {
#(#builders)*
}
},
)
}
pub fn comparison(
header: &UnitHeader<'_>,
database: &syn::Ident,
crossings: &proc_macro2::TokenStream,
columns: &[ComparisonColumn],
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let (vis, name, subject) = (&header.vis, &header.name, &header.subject);
let members = columns.iter().map(|column| {
let (member, gate) = (&column.member, &column.gate);
quote!(#gate #member,)
});
let marker = columns
.is_empty()
.then(|| quote!(db: ::core::marker::PhantomData<fn() -> #database>,));
let fields = columns.iter().map(|column| {
let (member, held, gate) = (&column.member, &column.held, &column.gate);
quote!(#gate #member: #held,)
});
let doc = header.doc(&format!(
"A predicate over a {subject}'s columns, in the types this database stores — each field the \
comparison its column's filter crosses into, so a query may ask for any shape that column's \
operators offer rather than equality alone."
));
let declaration = quote! {
#[doc = #doc]
#vis struct #name<#database>
where
#crossings
{
#(#fields)*
#marker
}
};
let accessors = columns.iter().map(|column| {
let (member, held, gate) = (&column.member, &column.held, &column.gate);
let borrow = Member::Borrow.name(member);
let doc = crate::emit::leading(&format!(
"The predicate on the {}, in the type this database stores.",
column.name
));
quote! {
#gate
#[doc = #doc]
#[inline]
#vis const fn #borrow(&self) -> &#held {
&self.#member
}
}
});
let arguments = columns.iter().map(|column| {
let (member, held, gate) = (&column.member, &column.held, &column.gate);
quote!(#gate #member: #held,)
});
let marker_field = columns
.is_empty()
.then(|| quote!(db: ::core::marker::PhantomData,));
let new_doc = crate::emit::leading(
"Construct a predicate from one comparison per column, in the order this database stores them.",
);
let arity = crate::emit::wide_signature();
(
declaration,
quote! {
impl<#database> #name<#database>
where
#crossings
{
#[doc = #new_doc]
#arity
#[inline]
#vis const fn new(#(#arguments)*) -> Self {
Self { #(#members)* #marker_field }
}
#(#accessors)*
}
},
)
}
pub fn order_by(
header: &UnitHeader<'_>,
direction_ty: &proc_macro2::TokenStream,
columns: &[OrderColumn],
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let (vis, name, subject) = (&header.vis, &header.name, &header.subject);
let variants = columns.iter().map(|column| {
let (variant, gate) = (&column.variant, &column.gate);
let doc = crate::emit::leading(¬ed(
&format!("Order by the {}, in the direction given.", column.name),
column.note.as_deref(),
));
quote! {
#gate
#[doc = #doc]
#variant(#direction_ty),
}
});
let doc = header.doc(&format!(
"One ordering term over a {subject} — which column, and which way it runs."
));
let declaration = quote! {
#[doc = #doc]
#[derive(
::core::fmt::Debug, ::core::clone::Clone,
::core::marker::Copy,
::core::cmp::PartialEq,
::core::cmp::Eq
)]
#vis enum #name {
#(#variants)*
}
};
let conditional = columns.iter().any(|column| !column.gate.is_empty());
let body = if columns.is_empty() {
quote!(match self {})
} else if conditional {
let arms = columns.iter().map(|column| {
let (variant, gate) = (&column.variant, &column.gate);
quote!(#gate Self::#variant(direction) => direction,)
});
quote! {
match self {
#(#arms)*
}
}
} else {
let bindings = columns.iter().map(|column| {
let variant = &column.variant;
quote!(Self::#variant(direction))
});
quote! {
match self {
#(#bindings)|* => direction,
}
}
};
let doc = crate::emit::leading("Which way this term runs.");
(
declaration,
quote! {
#[doc = #doc]
#[inline]
#vis const fn direction(self) -> #direction_ty {
#body
}
},
)
}
pub fn order_identity(
vis: &syn::Visibility,
term_name: &proc_macro2::TokenStream,
columns: &[OrderColumn],
) -> proc_macro2::TokenStream {
let identities = columns.iter().map(|column| {
let (variant, identity, gate) = (&column.variant, &column.identity, &column.gate);
quote!(#gate Self::#variant(_) => #term_name::new(#identity),)
});
let body = if columns.is_empty() {
quote!(match self {})
} else {
quote! {
match self {
#(#identities)*
}
}
};
let doc = crate::emit::leading(
"WHICH column this term names, under the name a per-database rename cannot move — what a \
cursor's signature is folded from.",
);
quote! {
#[doc = #doc]
#[inline]
#vis const fn identity(self) -> &'static #term_name {
#body
}
}
}
pub fn order_subject_path(
name: &syn::Ident,
to_subject_path: &proc_macro2::TokenStream,
subject_path: &proc_macro2::TokenStream,
term_name: &proc_macro2::TokenStream,
columns: &[OrderColumn],
) -> proc_macro2::TokenStream {
let subjects = columns.iter().map(|column| {
let (variant, identity, gate) = (&column.variant, &column.identity, &column.gate);
quote! {
#gate
Self::#variant(_) => {
const __INGRAPH_SUBJECT: #subject_path =
#subject_path::new(&[#term_name::new(#identity)]);
__INGRAPH_SUBJECT
}
}
});
let body = if columns.is_empty() {
quote!(match *self {})
} else {
quote! {
match *self {
#(#subjects)*
}
}
};
quote! {
#[automatically_derived]
impl #to_subject_path for #name {
#[inline]
fn subject_path(&self) -> #subject_path {
#body
}
}
}
}
pub struct LoweringColumn {
pub member: syn::Ident,
pub rendered: String,
pub flatten: bool,
pub through: Option<proc_macro2::TokenStream>,
pub gate: proc_macro2::TokenStream,
}
impl LoweringColumn {
#[must_use]
pub fn unframed(member: syn::Ident, through: proc_macro2::TokenStream) -> Self {
Self {
member,
rendered: String::new(),
flatten: true,
through: Some(through),
gate: proc_macro2::TokenStream::new(),
}
}
#[must_use]
pub fn framed(
member: syn::Ident,
rendered: String,
through: Option<proc_macro2::TokenStream>,
) -> Self {
Self {
member,
rendered,
flatten: false,
through,
gate: proc_macro2::TokenStream::new(),
}
}
#[must_use]
pub fn with_gate(mut self, gate: proc_macro2::TokenStream) -> Self {
self.gate = gate;
self
}
}
pub struct LoweringSeats {
pub backend: proc_macro2::TokenStream,
pub complex: proc_macro2::TokenStream,
pub frame: proc_macro2::TokenStream,
pub at: proc_macro2::TokenStream,
pub field_name: proc_macro2::TokenStream,
}
pub fn comparison_lowering(
name: &syn::Ident,
database: &syn::Ident,
crossings: &proc_macro2::TokenStream,
seats: &LoweringSeats,
columns: &[LoweringColumn],
) -> proc_macro2::TokenStream {
let LoweringSeats {
backend,
complex,
frame,
at,
field_name,
} = seats;
let door = |column: &LoweringColumn| {
column
.through
.clone()
.unwrap_or_else(|| quote!(#complex::<#database>))
};
let conditional = columns.iter().any(|column| !column.gate.is_empty());
let conjuncts = if columns.is_empty() {
quote!(0)
} else if conditional {
let counts = columns.iter().map(|column| {
let (member, door, gate) = (&column.member, door(column), &column.gate);
quote! {
#gate
{
__ingraph_conjuncts += #door::conjuncts(&self.#member);
}
}
});
quote! {
{
let mut __ingraph_conjuncts = 0usize;
#(#counts)*
__ingraph_conjuncts
}
}
} else {
let counts = columns.iter().map(|column| {
let (member, door) = (&column.member, door(column));
quote!(#door::conjuncts(&self.#member))
});
quote!(#(#counts)+*)
};
let parts = columns.iter().map(|column| {
let (member, rendered, door) = (&column.member, &column.rendered, door(column));
let gate = &column.gate;
if column.flatten {
return quote! {
#gate
let __ingraph_builder = #door::apply(
&self.#member,
__ingraph_at,
__ingraph_builder,
)?;
};
}
quote! {
#gate
let __ingraph_frame = #at::frame(__ingraph_at, #field_name::new(#rendered));
#gate
let __ingraph_builder = #door::apply(
&self.#member,
#frame::at(&__ingraph_frame),
__ingraph_builder,
)?;
}
});
let at_binding = if columns.is_empty() {
quote!(_)
} else {
quote!(__ingraph_at)
};
let conjuncts_doc = crate::emit::leading(
"How many conjuncts this predicate renders — the sum over its columns, since each is a \
comparison of its own.",
);
let apply_doc = crate::emit::leading(
"Render every column's conjuncts into `builder`, each at the same row and one segment below the \
address this predicate was applied at.",
);
quote! {
#[automatically_derived]
impl<#database> #complex<#database> for #name<#database>
where
#crossings
{
#[doc = #conjuncts_doc]
#[inline]
fn conjuncts(&self) -> ::core::primitive::usize {
#conjuncts
}
#[doc = #apply_doc]
fn apply<'q>(
&'q self,
#at_binding: #at<'_>,
__ingraph_builder: <#database as #backend>::Builder<'q>,
) -> ::core::result::Result<
<#database as #backend>::Builder<'q>,
<#database as #backend>::Error,
> {
#(#parts)*
::core::result::Result::Ok(__ingraph_builder)
}
}
}
}