use heck::ToUpperCamelCase as _;
use quote::{format_ident, quote};
use super::{MemberModel, SearchModel};
use crate::{
emit::{framework, leading},
fuse::{Packages, Row},
};
#[cfg(test)]
mod dedup_tests;
#[cfg(test)]
mod tests;
impl SearchModel {
#[must_use]
pub fn fuse(&self) -> proc_macro2::TokenStream {
let towers = self.tower_packages();
let packages = self.packages_emission();
let evidence = self.evidence();
let door = self.door();
quote! {
#towers
#packages
#evidence
#door
}
}
fn packages(&self) -> Packages<'_> {
Packages {
krate: &self.krate,
vis: &self.vis,
owner: &self.name,
graphql: None,
base: &self.name,
members: Vec::new(),
}
}
fn tower_packages(&self) -> proc_macro2::TokenStream {
let bound = self.members.iter().filter(|member| !member.arms.is_empty());
let minted = bound.map(|member| self.tower_package(member));
quote!(#(#minted)*)
}
fn tower_package(&self, member: &MemberModel) -> proc_macro2::TokenStream {
let declared = framework(&self.krate, &["retrieve"], "DeclaredTower");
let rows: Vec<Row> = member
.arms
.iter()
.map(|arm| {
let tower = &arm.tower;
Row::new(
&arm.name,
quote!(<#tower as #declared>::StepOptions),
&format!("`{}` tower", arm.name),
)
})
.collect();
self.packages().package(
&tower_options_name(&self.name, &member.field),
&format!(
"The knobs the towers bound to [`{recipe}`]'s `{member}` member run under — one row per \
arm, each holding that TOWER's own options object by projection.",
recipe = self.name,
member = member.field,
),
&rows,
)
}
fn packages_emission(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let route = framework(krate, &["retrieve"], "Route");
let flavour = framework(krate, &["retrieve"], "FusionOptions");
let fusable = framework(krate, &["retrieve"], "Fusable");
let packages = self.packages();
let mut rows = vec![Row::new(
&format_ident!("fusion"),
quote!(#flavour),
"fusion flavour",
)];
rows.extend(self.members.iter().map(|member| {
let ty = &member.ty;
Row::new(
&member.field,
quote!(#route<<#ty as #fusable>::Options>),
&format!("`{}` member", member.field),
)
}));
rows.extend(
self
.members
.iter()
.filter(|member| !member.arms.is_empty())
.map(|member| {
let package = tower_options_name(&self.name, &member.field);
Row::new(
&tower_row(&member.field),
quote!(#package),
&format!("towers bound to `{}`", member.field),
)
}),
);
let options = packages.package(
&self.options_name(),
&format!(
"The knobs a FUSED retrieve under [`{recipe}`] runs under — one route per member, each \
wearing the edge facts a request states about it (its weight in the fold, whether it is \
walked, and HOW DEEP to ask it) and holding that member's OWN package by projection, plus \
one seat per member for the towers this recipe bound to it.",
recipe = self.name,
),
&rows,
);
let mut asked = vec![Row::new(
&format_ident!("question"),
quote!(::std::string::String),
"question",
)];
asked.extend(self.members.iter().map(|member| {
let ty = &member.ty;
Row::new(
&member.field,
quote!(<#ty as #fusable>::Question),
&format!("`{}` member", member.field),
)
}));
let question = packages.question(
&self.question_name(),
&format!(
"The question a FUSED retrieve under [`{recipe}`] is asked with — the recipe's own, and one \
package per member for the members that ask something else. A member whose seat is EMPTY \
is not walked, which is the participation rule at recipe grain.",
recipe = self.name,
),
&asked,
);
quote! {
#options
#question
}
}
fn evidence(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let evidence = self.evidence_name();
let refusal = self.refusal_name();
let seen: Vec<syn::Ident> = self
.members
.iter()
.map(|member| evidence_param(&member.field))
.collect();
let errors: Vec<syn::Ident> = self
.members
.iter()
.map(|member| error_param(&member.field))
.collect();
let variants = self.members.iter().zip(&seen).map(|(member, param)| {
let variant = variant(&member.field);
let doc = leading(&format!(
"`{member}` ranked this root, and what `{member}` itself saw — that member's own \
provenance, whole.",
member = member.field,
));
quote! {
#[doc = #doc]
#variant(#param)
}
});
let refusals = self.members.iter().zip(&errors).map(|(member, param)| {
let variant = variant(&member.field);
let doc = leading(&format!(
"`{member}` refused, in that member's own vocabulary.",
member = member.field,
));
quote! {
#[doc = #doc]
#variant(#param)
}
});
let arms = self.members.iter().map(|member| {
let variant = variant(&member.field);
let field = member.field.to_string();
quote! {
Self::#variant(__ingraph_refusal) => {
::core::write!(__ingraph_formatter, "{}: {__ingraph_refusal}", #field)
}
}
});
let sources = self.members.iter().map(|member| {
let variant = variant(&member.field);
quote!(Self::#variant(__ingraph_refusal) => ::core::option::Option::Some(__ingraph_refusal))
});
let displays = errors
.iter()
.map(|param| quote!(#param: ::core::fmt::Display));
let bounds = errors
.iter()
.map(|param| quote!(#param: ::core::error::Error + 'static));
let doc = leading(&format!(
"WHICH of [`{recipe}`]'s members agreed about a fused root, and what each of them saw — one \
variant per member, each carrying that member's OWN evidence untouched.",
recipe = self.name,
));
let refusal_doc = leading(&format!(
"WHICH of [`{recipe}`]'s members refused, in that member's own vocabulary.",
recipe = self.name,
));
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis enum #evidence<#(#seen,)*> {
#(#variants,)*
}
#[doc = #refusal_doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis enum #refusal<#(#errors,)*> {
#(#refusals,)*
}
#[automatically_derived]
impl<#(#displays,)*> ::core::fmt::Display for #refusal<#(#errors,)*> {
fn fmt(
&self,
__ingraph_formatter: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
match self {
#(#arms,)*
}
}
}
#[automatically_derived]
impl<#(#bounds,)*> ::core::error::Error for #refusal<#(#errors,)*> {
fn source(&self) -> ::core::option::Option<&(dyn ::core::error::Error + 'static)> {
match self {
#(#sources,)*
}
}
}
}
}
fn door(&self) -> proc_macro2::TokenStream {
let SearchModel {
krate, vis, dedup, ..
} = self;
let read = framework(krate, &["retrieve"], "AsyncFusedRead");
let route = framework(krate, &["retrieve"], "Route");
let flavour = framework(krate, &["retrieve"], "FusionOptions");
let fusion = framework(krate, &["retrieve"], "Fusion");
let fused = framework(krate, &["retrieve"], "Fused");
let rooted = framework(krate, &["retrieve"], "Rooted");
let weighted = framework(krate, &["retrieve"], "fuse_weighted");
let join = framework(krate, &["retrieve"], dedup.join());
let admits = dedup.admits();
let recipe = &self.name;
let key = format_ident!("__INGRAPH_ROOT__");
let options = self.options_name();
let question = self.question_name();
let evidence = self.evidence_name();
let refusal = self.refusal_name();
let engines: Vec<syn::Ident> = self
.members
.iter()
.map(|member| engine_param(&member.field))
.collect();
let seen: Vec<proc_macro2::TokenStream> = self
.members
.iter()
.zip(&engines)
.map(|(member, engine)| {
let ty = &member.ty;
quote!(<#ty as #read<#engine>>::Evidence)
})
.collect();
let errors: Vec<proc_macro2::TokenStream> = self
.members
.iter()
.zip(&engines)
.map(|(member, engine)| {
let ty = &member.ty;
quote!(<#ty as #read<#engine>>::Error)
})
.collect();
let params = self.members.iter().zip(&engines).map(|(member, engine)| {
let field = &member.field;
let ty = &member.ty;
quote!(#field: <#ty as #read<#engine>>::Ctx<'__ingraph_ctx>,)
});
let obligations = self.members.iter().zip(&engines).map(|(member, engine)| {
let ty = &member.ty;
quote! {
#engine: '__ingraph_ctx,
#ty: #read<#engine, Root = #key>,
}
});
let asks = self.members.iter().zip(&engines).map(|(member, engine)| {
let field = &member.field;
let ty = &member.ty;
let variant = variant(field);
let edge = self.member_edge(member);
quote! {
{
#edge
if let (true, ::core::option::Option::Some(__ingraph_asked)) =
(__ingraph_enabled, #question::#field(question))
{
let __ingraph_ranked = <#ty as #read<#engine>>::keys(
#field,
::core::option::Option::and_then(__ingraph_route, #route::options),
__ingraph_asked,
__ingraph_depth,
)
.await
.map_err(#refusal::#variant)?;
__ingraph_members.push((
__ingraph_weight,
::core::iter::Iterator::collect::<::std::vec::Vec<_>>(
::core::iter::Iterator::map(
::std::vec::Vec::into_iter(__ingraph_ranked),
|__ingraph_hit| {
let (__ingraph_root, __ingraph_rank, __ingraph_seen) =
__ingraph_hit.into_components();
#rooted::new(
__ingraph_root,
__ingraph_rank,
#evidence::#variant(__ingraph_seen),
)
},
),
),
));
}
}
}
});
let doc = leading(&format!(
"FUSED — every member [`{recipe}`] lists asked at once, their rankings joined by reciprocal \
rank fusion. Answers in the key every one of them agrees about.",
));
let projection = leading(
"This recipe names NOTHING of a member's: the context, the package, the question, the \
evidence and the refusal are all projections, so a third-party member joins by implementing \
`AsyncFusedRead` and this door absorbs it with no edit here.",
);
let currency = leading(
"No score of any member enters the fusion — only the ORDINAL each of them gave the hit — which \
is what lets members whose currencies were never compared be fused at all. Each member's own \
evidence rides out NESTED instead, whole and unopened.",
);
let key_note = leading(
"The ROOT is a parameter and never a type this emission names: every member's own key is \
bound to it, so two members answering two key types have no root to be fused at and say so \
as `E0271` at this call.",
);
let mechanism = leading(&format!(
"Roots are placed through `{join}`, which is what this recipe's `dedup({word})` chose — the \
`where` row below is that mechanism's price. The law it answers is that a key that cannot \
hash is retrievable, so a member that reached for `dedup(eq)` for that reason must not \
become unfusable in a recipe that lists it.",
join = dedup.join(),
word = dedup.as_str(),
));
quote! {
#[automatically_derived]
impl #recipe {
#[doc = #doc]
#[doc = ""]
#[doc = #projection]
#[doc = ""]
#[doc = #key_note]
#[doc = ""]
#[doc = #currency]
#[doc = ""]
#[doc = #mechanism]
#[allow(clippy::too_many_arguments)]
#vis async fn fuse<'__ingraph_ctx, #key, #(#engines),*>(
#(#params)*
options: ::core::option::Option<&#options>,
question: &#question,
limit: ::core::num::NonZeroUsize,
) -> ::core::result::Result<
::std::vec::Vec<#fused<#key, #evidence<#(#seen,)*>>>,
#refusal<#(#errors,)*>,
>
where
#key: #admits,
#(#obligations)*
{
let __ingraph_fusion = ::core::option::Option::map_or(
::core::option::Option::and_then(options, #options::fusion),
<#fusion as ::core::default::Default>::default(),
#flavour::fusion,
);
let mut __ingraph_members = ::std::vec::Vec::new();
#(#asks)*
::core::result::Result::Ok(
#weighted::<_, _, #join<#key>>(__ingraph_members, __ingraph_fusion)
)
}
}
}
}
pub(super) fn member_edge(&self, member: &MemberModel) -> proc_macro2::TokenStream {
let krate = &self.krate;
let route = framework(krate, &["retrieve"], "Route");
let depth = framework(krate, &["retrieve"], "route_depth");
let fusable = framework(krate, &["retrieve"], "Fusable");
let options = self.options_name();
let field = &member.field;
let ty = &member.ty;
let declared_weight = member.weight.map_or_else(
|| quote!(#route::<<#ty as #fusable>::Options>::DEFAULT_WEIGHT),
|weight| quote!(#weight),
);
let declared_depth = member.depth.map_or_else(
|| quote!(::core::option::Option::None),
|depth| {
let depth = depth.get();
quote!(::core::num::NonZeroU32::new(#depth))
},
);
quote! {
let __ingraph_route = ::core::option::Option::and_then(options, #options::#field);
let __ingraph_enabled = ::core::option::Option::map_or(
__ingraph_route,
#route::<<#ty as #fusable>::Options>::DEFAULT_ENABLED,
#route::enabled,
);
let __ingraph_weight = ::core::option::Option::map_or(
__ingraph_route,
#declared_weight,
#route::weight,
);
let __ingraph_declared: ::core::option::Option<::core::num::NonZeroU32> = #declared_depth;
let __ingraph_depth = #depth(
::core::option::Option::and_then(__ingraph_route, #route::depth),
::core::option::Option::as_ref(&__ingraph_declared),
limit,
);
}
}
pub(super) fn options_name(&self) -> syn::Ident {
format_ident!("{}FuseOptions", self.name)
}
pub(super) fn question_name(&self) -> syn::Ident {
format_ident!("{}FuseQuestion", self.name)
}
pub(super) fn evidence_name(&self) -> syn::Ident {
format_ident!("{}FusedEvidence", self.name)
}
pub(super) fn refusal_name(&self) -> syn::Ident {
format_ident!("{}FusedError", self.name)
}
}
fn tower_options_name(recipe: &syn::Ident, member: &syn::Ident) -> syn::Ident {
format_ident!(
"{recipe}{}TowerOptions",
member.to_string().to_upper_camel_case()
)
}
fn tower_row(member: &syn::Ident) -> syn::Ident {
format_ident!("{member}_towers")
}
fn variant(field: &syn::Ident) -> syn::Ident {
format_ident!("{}", field.to_string().to_upper_camel_case())
}
fn engine_param(field: &syn::Ident) -> syn::Ident {
crate::fuse::engine_param(field)
}
fn evidence_param(field: &syn::Ident) -> syn::Ident {
use heck::ToShoutySnakeCase as _;
format_ident!(
"__INGRAPH_EVIDENCE_{}__",
field.to_string().to_shouty_snake_case()
)
}
fn error_param(field: &syn::Ident) -> syn::Ident {
crate::fuse::error_param(field)
}