use quote::{quote, quote_spanned};
use crate::emit::respan;
#[cfg(test)]
mod tests;
#[derive(Debug, Clone)]
pub struct StepModel {
pub field: syn::Ident,
pub ty: syn::Type,
pub answer: Option<syn::Type>,
pub awaited: bool,
pub fan: Option<Fan>,
pub annotation: Option<syn::Type>,
}
struct SearchRow {
member: syn::Ident,
wire: &'static str,
ty: proc_macro2::TokenStream,
noun: &'static str,
why: &'static str,
}
impl StepModel {
#[must_use]
pub fn stage(&self) -> Option<Stage> {
match (&self.annotation, &self.fan) {
(Some(_), _) => Some(Stage::Annotate),
(None, Some(fan)) => Some(fan.stage()),
(None, None) => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Stage {
Annotate,
Expand,
Route,
}
impl Stage {
#[must_use]
pub const fn word(self) -> &'static str {
match self {
Self::Annotate => "annotate",
Self::Expand => "expand",
Self::Route => "route",
}
}
#[must_use]
pub const fn why_first(self) -> &'static str {
match self {
Self::Annotate => {
"a question is ANNOTATED before it is anything else, because the stages after it READ what \
it wrote — the widening's targets and the crossing's lanes both come off the annotation — \
and a step's answer travels downstream only, so a stage that filled the seat later would \
fill it for nobody"
}
Self::Expand => {
"a question is WIDENED before it is CROSSED, because a widening is an endomorphism over \
QUESTIONS and a crossing turns one into PROBES — so an expansion after a routing would \
have to widen a probe, in whatever currency the store behind that lane chose"
}
Self::Route => {
"a question is CROSSED last, because a crossing is what stops there being a question: what \
it answers is one probe per lane, and every stage of this pipeline that takes a question \
has already run"
}
}
}
}
#[derive(Debug, Clone)]
pub enum Router {
FanAll,
ScriptRouter,
ScriptWeightedFan,
Declared(syn::Path),
}
impl Router {
pub const SHIPPED: [&'static str; 3] = ["fan_all", "script_router", "script_weighted_fan"];
#[must_use]
pub fn shipped(word: &str) -> Option<Self> {
match word {
"fan_all" => Some(Self::FanAll),
"script_router" => Some(Self::ScriptRouter),
"script_weighted_fan" => Some(Self::ScriptWeightedFan),
_ => None,
}
}
#[must_use]
pub fn as_written(&self) -> String {
match self {
Self::FanAll => Self::SHIPPED[0].to_owned(),
Self::ScriptRouter => Self::SHIPPED[1].to_owned(),
Self::ScriptWeightedFan => Self::SHIPPED[2].to_owned(),
Self::Declared(path) => quote::ToTokens::to_token_stream(path).to_string(),
}
}
#[must_use]
pub fn spelled(
&self,
krate: &syn::Path,
question: &proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
match self {
Self::FanAll => quote!(#krate::__private::route::FanAll<#question>),
Self::ScriptRouter => quote!(#krate::__private::route::ScriptRouter),
Self::ScriptWeightedFan => quote!(#krate::__private::route::ScriptWeightedFan<#question>),
Self::Declared(path) => quote!(#path),
}
}
}
#[derive(Debug, Clone)]
pub enum Fan {
Expand {
expander: syn::Path,
},
Route {
router: Router,
slot: syn::Path,
},
}
impl Fan {
#[must_use]
pub const fn stage(&self) -> Stage {
match self {
Self::Expand { .. } => Stage::Expand,
Self::Route { .. } => Stage::Route,
}
}
#[must_use]
pub const fn word(&self) -> &'static str {
self.stage().word()
}
}
#[derive(Debug, Clone)]
pub struct TowerModel {
pub krate: syn::Path,
pub name: syn::Ident,
pub vis: syn::Visibility,
pub question: Option<syn::Type>,
pub answer: Option<syn::Type>,
pub steps: Vec<StepModel>,
}
impl TowerModel {
#[must_use]
pub fn emit(&self) -> proc_macro2::TokenStream {
let connectivity = self.connectivity();
let pin = self.pin();
let options = self.options();
let asked = self.search_options();
let declared = self.declared();
let refusal = self.refusal();
let rendering = self.rendering();
let walk = self.walk();
let assembly = self.assembly();
quote! {
#connectivity
#pin
#options
#asked
#declared
#refusal
#rendering
#walk
#assembly
}
}
#[must_use]
pub fn awaited(&self) -> bool {
self.steps.iter().any(|step| step.awaited) || self.expand_at().is_some()
}
#[must_use]
pub fn expand_at(&self) -> Option<usize> {
self
.fans()
.find(|(_, _, fan)| fan.stage() == Stage::Expand)
.map(|(at, _, _)| at)
}
#[must_use]
pub fn annotate_at(&self) -> Option<usize> {
self.steps.iter().position(|step| step.annotation.is_some())
}
#[must_use]
pub fn route_at(&self) -> Option<usize> {
self
.fans()
.find(|(_, _, fan)| fan.stage() == Stage::Route)
.map(|(at, _, _)| at)
}
pub fn fans(&self) -> impl Iterator<Item = (usize, &StepModel, &Fan)> {
self
.steps
.iter()
.enumerate()
.filter_map(|(at, step)| step.fan.as_ref().map(|fan| (at, step, fan)))
}
#[must_use]
pub fn fanned(&self) -> bool {
self.steps.iter().any(|step| step.fan.is_some())
}
#[must_use]
pub fn step_options_name(&self) -> syn::Ident {
quote::format_ident!("{}StepOptions", self.name, span = self.name.span())
}
#[must_use]
pub fn search_options_name(&self) -> syn::Ident {
quote::format_ident!("{}SearchOptions", self.name, span = self.name.span())
}
#[must_use]
pub fn weighted_crossing(&self) -> Option<(usize, &StepModel)> {
self.fans().find_map(|(at, step, fan)| match fan {
Fan::Route {
router: Router::ScriptWeightedFan,
..
} => Some((at, step)),
Fan::Route { .. } | Fan::Expand { .. } => None,
})
}
#[must_use]
pub fn error_name(&self) -> syn::Ident {
quote::format_ident!("{}Error", self.name, span = self.name.span())
}
fn variant(step: &StepModel) -> syn::Ident {
use heck::ToUpperCamelCase as _;
use syn::ext::IdentExt as _;
quote::format_ident!(
"{}",
step.field.unraw().to_string().to_upper_camel_case(),
span = step.field.span()
)
}
fn canonical(&self, step: &StepModel, seat: &str) -> proc_macro2::TokenStream {
let at_field = step.field.span();
let ty = &step.ty;
let line = respan(
{
let krate = &self.krate;
quote!(#krate::__private::drive::DefaultServe)
},
at_field,
);
let seat = quote::format_ident!("{seat}", span = at_field);
quote_spanned!(at_field=> <#ty as #line>::#seat)
}
fn asked(&self) -> proc_macro2::TokenStream {
match (&self.question, self.steps.first()) {
(Some(question), _) => quote!(#question),
(None, Some(head)) => self.canonical(head, "Question"),
(None, None) => quote!(()),
}
}
fn answered(&self, step: &StepModel) -> proc_macro2::TokenStream {
step
.answer
.as_ref()
.map_or_else(|| self.canonical(step, "Answer"), |answer| quote!(#answer))
}
fn derived(&self) -> proc_macro2::TokenStream {
let Some(tail) = self.steps.last() else {
return quote!(());
};
let answers = self.flows(self.steps.len() - 1);
if !self.fanned() {
return answers;
}
let krate = &self.krate;
let at_field = tail.field.span();
let stream = respan(quote!(#krate::__private::retrieve::RankedStream), at_field);
let fused = respan(quote!(#krate::__private::retrieve::Fused), at_field);
quote_spanned! {at_field=>
::std::vec::Vec<#fused<
<#answers as #stream>::Root,
<#answers as #stream>::Evidence,
>>
}
}
fn tail(&self) -> proc_macro2::TokenStream {
match self.steps.len().checked_sub(1) {
Some(last) => self.flows(last),
None => quote!(()),
}
}
fn takes(&self, at: usize) -> proc_macro2::TokenStream {
match at
.checked_sub(1)
.filter(|before| *before < self.steps.len())
{
Some(before) => self.flows(before),
None => self.asked(),
}
}
fn flows(&self, at: usize) -> proc_macro2::TokenStream {
match self.steps.get(at) {
Some(step) if step.annotation.is_some() => self.takes(at),
Some(step) => self.answered(step),
None => quote!(()),
}
}
fn face(&self, step: &StepModel) -> proc_macro2::TokenStream {
let krate = &self.krate;
if step.awaited {
quote!(#krate::__private::drive::AsyncServes)
} else {
quote!(#krate::__private::drive::Serves)
}
}
fn connectivity(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let name = &self.name;
let question = self.asked();
let answer = self.derived();
let hops = self.hops();
quote! {
impl #krate::__private::retrieve::SearchTower for #name
where
#(#hops,)*
{
type Question = #question;
type Answer = #answer;
type Steps = #name;
}
}
}
fn hops(&self) -> Vec<proc_macro2::TokenStream> {
let krate = &self.krate;
self
.steps
.iter()
.enumerate()
.flat_map(|(at, step)| {
let at_field = step.field.span();
let ty = &step.ty;
let takes = self.takes(at);
let answers = self.flows(at);
if let Some(annotation) = &step.annotation {
let seam = respan(
quote!(#krate::__private::retrieve::AnnotatedQuestion),
at_field,
);
let face = respan(self.face(step), at_field);
return vec![
quote_spanned!(at_field=> #ty: #face<#takes, #takes>),
quote_spanned!(at_field=> #takes: #seam<#annotation>),
];
}
if step.fan.is_some() {
let line = respan(
{
let krate = &self.krate;
quote!(#krate::__private::drive::DefaultServe)
},
at_field,
);
let mut bindings: Vec<proc_macro2::TokenStream> = Vec::new();
if at > 0 || self.question.is_some() {
bindings.push(quote_spanned!(at_field=> Question = #takes));
}
if step.answer.is_some() {
bindings.push(quote_spanned!(at_field=> Answer = #answers));
}
let stated = if bindings.is_empty() {
quote_spanned!(at_field=> #ty: #line)
} else {
quote_spanned!(at_field=> #ty: #line<#(#bindings),*>)
};
let mut demanded = vec![stated];
if let Some(Fan::Expand { expander }) = &step.fan {
let krate = &self.krate;
let seam = respan(
quote!(#krate::__private::retrieve::AsyncQueryExpander),
at_field,
);
demanded.push(quote_spanned!(at_field=> #expander: #seam<#takes>));
}
if let Some(Fan::Route { router, slot }) = &step.fan {
let krate = &self.krate;
let router = router.spelled(krate, &takes);
let seam = respan(quote!(#krate::__private::route::LaneRouter), at_field);
let laned = respan(quote!(#krate::__private::lane::LanedStore), at_field);
demanded
.push(quote_spanned!(at_field=> #router: #seam<Routed = <#slot as #laned>::Probe>));
}
return demanded;
}
let face = respan(self.face(step), at_field);
vec![quote_spanned!(at_field=> #ty: #face<#takes, #answers>)]
})
.collect()
}
fn pin(&self) -> Option<proc_macro2::TokenStream> {
use syn::spanned::Spanned as _;
let claimed = self.answer.as_ref()?;
let krate = &self.krate;
let at = claimed.span();
let audit = quote::format_ident!("__ingraph_a_tower_answers_the_type_its_answer_word_named");
let spent = respan(
{
let name = &self.name;
quote!(#name)
},
at,
);
let spend = quote_spanned!(at=> const _: fn() = #audit::<#spent>;);
Some(quote! {
const _: () = {
fn #audit<__IgTower>()
where
__IgTower: #krate::__private::retrieve::SearchTower<Answer = #claimed>,
{
}
#spend
};
})
}
fn seat(&self, step: &StepModel) -> proc_macro2::TokenStream {
let at_field = step.field.span();
let ty = &step.ty;
let base = respan(
{
let krate = &self.krate;
quote!(#krate::__private::drive::Serve)
},
at_field,
);
quote_spanned!(at_field=> <#ty as #base>::Options)
}
fn options(&self) -> proc_macro2::TokenStream {
use syn::ext::IdentExt as _;
let vis = &self.vis;
let name = self.step_options_name();
let rows = self.steps.iter().map(|step| {
let field = &step.field;
let seat = self.seat(step);
let doc = crate::emit::leading(&format!(
"What the `{field}` step is served with, where this call names it.",
field = step.field,
));
quote! {
#[doc = #doc]
#field: ::core::option::Option<#seat>
}
});
let nothing = self.steps.iter().map(|step| {
let field = &step.field;
quote!(#field: ::core::option::Option::None,)
});
let knobs = self.steps.iter().map(|step| {
let field = &step.field;
let bare = field.unraw();
let seat = self.seat(step);
let with = quote::format_ident!("with_{bare}", span = step.field.span());
let set = quote::format_ident!("set_{bare}", span = step.field.span());
let named = crate::emit::leading(&format!(
"The same options, naming what the `{field}` step is served with.\n\nA step whose server \
seats `()` takes NO knobs — its seat is the ANSWER *this server is configured with \
nothing* — so this parameter is `()` there and knobs written for one are refused right \
here, at the step's own name.",
field = step.field,
));
let narrowed = crate::emit::leading(&format!(
"What the `{field}` step is served with, named IN PLACE — including named back to nothing.",
field = step.field,
));
let read = crate::emit::leading(&format!(
"What this call names for the `{field}` step, or [`None`] where it names nothing — under \
which that step runs at its own floor.",
field = step.field,
));
quote! {
#[doc = #named]
#[inline]
#[must_use]
#vis fn #with(mut self, #field: #seat) -> Self {
self.#field = ::core::option::Option::Some(#field);
self
}
#[doc = #narrowed]
#[inline]
#vis fn #set(&mut self, #field: ::core::option::Option<#seat>) -> &mut Self {
self.#field = #field;
self
}
#[doc = #read]
#[inline]
#[must_use]
#vis fn #field(&self) -> ::core::option::Option<&#seat> {
::core::option::Option::as_ref(&self.#field)
}
}
});
let doc = crate::emit::leading(&format!(
"What a caller names for [`{name}`]'s steps — ONE FIELD PER STEP, each that step's own \
`Serve::Options` seat.\n\nEvery field starts at nothing, and nothing is a LEVEL rather than \
a gap: a step this names nothing for is served under `None` and runs at its own floor, which \
is what a step author's own default is for. A step whose server seats `()` takes no knobs at \
all, so its row here is zero-sized and nothing reads it.",
name = self.name,
));
let fresh = crate::emit::leading(&format!(
"Options that name NOTHING — every step of [`{name}`] at its own floor.",
name = self.name,
));
let defaulted = crate::emit::leading(&format!(
"The unnamed options — [`{name}::new`], and one source of truth for them.",
name = name,
));
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis struct #name {
#(#rows,)*
}
impl #name {
#[doc = #fresh]
#[inline]
#[must_use]
#vis const fn new() -> Self {
Self {
#(#nothing)*
}
}
#(#knobs)*
}
#[doc = #defaulted]
impl ::core::default::Default for #name {
#[inline]
fn default() -> Self {
Self::new()
}
}
}
}
fn declared(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let name = &self.name;
let step_options = self.step_options_name();
let search_options = self.search_options_name();
let all_sync = !self.awaited();
let rows = self.steps.iter().map(|step| {
use syn::ext::IdentExt as _;
let field = step.field.unraw().to_string();
let row = quote!(#krate::__private::retrieve::Step::of(#field));
if step.awaited {
quote!(#row.awaited())
} else {
row
}
});
quote! {
impl #krate::__private::retrieve::DeclaredTower for #name {
type StepOptions = #step_options;
type SearchOptions = #search_options;
const ALL_SYNC: bool = #all_sync;
const STEPS: &'static [#krate::__private::retrieve::Step] = &[
#(#rows),*
];
}
}
}
fn search_options(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let vis = &self.vis;
let name = self.search_options_name();
let sdl = name.to_string();
let at = self.name.span();
let budget = respan(quote!(#krate::__private::retrieve::SearchBudget), at);
let mut rows: Vec<SearchRow> = vec![SearchRow {
member: quote::format_ident!("budget", span = at),
wire: "budget",
ty: budget,
noun: "walk budget",
why: "How long this request will wait for the whole walk. The deployment's own wall CAPS it: \
a request asking for less waits less, and one asking for more waits the deployment's \
number.",
}];
if let Some(at_expand) = self.expand_at() {
let at_field = self.steps[at_expand].field.span();
rows.push(SearchRow {
member: quote::format_ident!("arm_weight", span = at_field),
wire: "armWeight",
ty: quote_spanned!(at_field=> ::core::primitive::f64),
noun: "arm weight",
why: "What an arm the expander minted counts for, against the 1.0 of what was actually \
asked. A PREFERENCE, so a request that names it wins outright over the deployment's.",
});
}
if let Some((_, step)) = self.weighted_crossing() {
let at_field = step.field.span();
rows.push(SearchRow {
member: quote::format_ident!("lane_emphasis", span = at_field),
wire: "laneEmphasis",
ty: quote_spanned!(at_field=> ::core::primitive::f64),
noun: "lane emphasis",
why: "What a lane this question is written in counts for, against the 1.0 of every other \
lane. A PREFERENCE, and 1.0 asks every lane flat.",
});
}
let fields = rows.iter().map(
|SearchRow {
member,
ty,
noun,
why,
..
}| {
let doc = crate::emit::leading(&format!(
"The {noun}, where this request names one.\n\n{why}\n\nAbsent means THIS REQUEST NAMED \
NOTHING, under which the deployment's own value stands.",
));
quote!(#[doc = #doc] #member: ::core::option::Option<#ty>)
},
);
let nothing = rows
.iter()
.map(|SearchRow { member, .. }| quote!(#member: ::core::option::Option::None,));
let knobs = rows.iter().map(
|SearchRow {
member, ty, noun, ..
}| {
let with = quote::format_ident!("with_{member}", span = member.span());
let set = quote::format_ident!("set_{member}", span = member.span());
let named = crate::emit::leading(&format!("The same request, naming the {noun}."));
let narrowed = crate::emit::leading(&format!(
"The {noun}, named IN PLACE — including named back to nothing.",
));
let read = crate::emit::leading(&format!(
"The {noun}, or [`None`] where this request named nothing.",
));
quote! {
#[doc = #named]
#[inline]
#[must_use]
#vis fn #with(mut self, #member: #ty) -> Self {
self.#member = ::core::option::Option::Some(#member);
self
}
#[doc = #narrowed]
#[inline]
#vis fn #set(&mut self, #member: ::core::option::Option<#ty>) -> &mut Self {
self.#member = #member;
self
}
#[doc = #read]
#[inline]
#[must_use]
#vis fn #member(&self) -> ::core::option::Option<&#ty> {
::core::option::Option::as_ref(&self.#member)
}
}
},
);
let doc = crate::emit::leading(&format!(
"What ONE REQUEST names for [`{name}`] — the tier-three package, keyed by the words this \
declaration wrote.\n\nEvery field starts at nothing, and nothing is a DEFERRAL rather than a \
gap: a row this names nothing for leaves the deployment's own value standing. A PREFERENCE \
row that IS named wins outright; the budget is PROTECTIVE and may only tighten.",
name = self.name,
));
let fresh = crate::emit::leading(
"A request that names NOTHING — every tier-three row deferred to the \
deployment's.",
);
let defaulted = crate::emit::leading(&format!(
"The unnamed request — [`{name}::new`], and one source of truth for it.",
name = name,
));
let face = self.search_options_face(&name, &sdl, &rows);
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::cmp::PartialEq)]
#vis struct #name {
#(#fields,)*
}
impl #name {
#[doc = #fresh]
#[inline]
#[must_use]
#vis const fn new() -> Self {
Self {
#(#nothing)*
}
}
#(#knobs)*
}
#[doc = #defaulted]
impl ::core::default::Default for #name {
#[inline]
fn default() -> Self {
Self::new()
}
}
#face
}
}
fn search_options_face(
&self,
name: &syn::Ident,
sdl: &str,
rows: &[SearchRow],
) -> proc_macro2::TokenStream {
let krate = &self.krate;
let gate = quote!(#krate::__private::gate::if_async_graphql);
let ag = quote!(#krate::__private::async_graphql);
let entries = rows.iter().map(|SearchRow { wire, ty, why, .. }| {
let description = *why;
quote! {
__ingraph_fields.insert(
::std::string::String::from(#wire),
#ag::registry::MetaInputValue {
name: ::std::string::String::from(#wire),
description: ::core::option::Option::Some(::std::string::String::from(#description)),
ty: <::core::option::Option<#ty> as #ag::InputType>::create_type_info(
__ingraph_registry,
),
deprecation: #ag::registry::Deprecation::NoDeprecated,
default_value: ::core::option::Option::None,
visible: ::core::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
is_secret: false,
directive_invocations: ::std::vec::Vec::new(),
},
);
}
});
let reads = rows.iter().map(
|SearchRow {
member, wire, ty, ..
}| {
quote! {
#member: <::core::option::Option<#ty> as #ag::InputType>::parse(
#ag::indexmap::IndexMap::get(&__ingraph_object, #wire).cloned(),
)
.map_err(#ag::InputValueError::propagate)?
}
},
);
let writes = rows.iter().map(|SearchRow { member, wire, .. }| {
quote! {
__ingraph_map.insert(
#ag::Name::new(#wire),
#ag::InputType::to_value(&self.#member),
);
}
});
let description = format!(
"What one request names for `{name}` — every row absent by default, and an absent row leaves \
the deployment's own value standing.",
name = self.name,
);
quote! {
#gate! {
const _: () = {
#[automatically_derived]
impl #ag::InputType for #name {
type RawValueType = Self;
#[inline]
fn type_name() -> ::std::borrow::Cow<'static, ::core::primitive::str> {
::std::borrow::Cow::Borrowed(#sdl)
}
fn create_type_info(
__ingraph_registry: &mut #ag::registry::Registry,
) -> ::std::string::String {
__ingraph_registry.create_input_type::<Self, _>(
#ag::registry::MetaTypeId::InputObject,
|__ingraph_registry| #ag::registry::MetaType::InputObject {
name: ::std::string::String::from(#sdl),
description: ::core::option::Option::Some(
::std::string::String::from(#description),
),
input_fields: {
let mut __ingraph_fields = #ag::indexmap::IndexMap::new();
#(#entries)*
__ingraph_fields
},
visible: ::core::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
rust_typename: ::core::option::Option::Some(::core::any::type_name::<Self>()),
oneof: false,
directive_invocations: ::std::vec::Vec::new(),
},
)
}
fn parse(
__ingraph_value: ::core::option::Option<#ag::Value>,
) -> #ag::InputValueResult<Self> {
if let ::core::option::Option::Some(#ag::Value::Object(__ingraph_object)) =
__ingraph_value
{
return ::core::result::Result::Ok(Self { #(#reads,)* });
}
::core::result::Result::Err(#ag::InputValueError::expected_type(
::core::option::Option::unwrap_or_default(__ingraph_value),
))
}
fn to_value(&self) -> #ag::Value {
let mut __ingraph_map = #ag::indexmap::IndexMap::new();
#(#writes)*
#ag::Value::Object(__ingraph_map)
}
#[inline]
fn as_raw_value(&self) -> ::core::option::Option<&Self::RawValueType> {
::core::option::Option::Some(self)
}
}
#[automatically_derived]
impl #ag::InputObjectType for #name {}
};
}
}
}
fn assembly(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let name = &self.name;
let question = self.asked();
let answer = self.derived();
let refusal = self.error_name();
let options = self.step_options_name();
let mut hops = self.canonical_demands();
hops.extend(self.hops());
let awaited = self.awaited().then(|| quote!(.await));
let gate = self.gate();
let borrowed = self.steps.iter().map(|step| {
let field = &step.field;
quote!(&mut __ingraph_steps__.#field,)
});
let asked = self.search_options_name();
let retuned = self.retuned();
let composed = self.composed();
quote! {
impl #krate::__private::retrieve::AssembledTower for #name
where
#(#hops,)*
{
type Refusal = #refusal;
#gate
#[inline]
fn asked_budget(
__ingraph_asked__: ::core::option::Option<&#asked>,
) -> ::core::option::Option<#krate::__private::jiff::SignedDuration> {
::core::option::Option::and_then(
::core::option::Option::and_then(__ingraph_asked__, #asked::budget),
#krate::__private::retrieve::SearchBudget::walk,
)
}
async fn run(
__ingraph_steps__: &mut #name,
question: #question,
options: ::core::option::Option<&#options>,
asked: ::core::option::Option<#asked>,
) -> ::core::result::Result<#answer, #refusal> {
#retuned
#composed
#name::walk(question, #(#borrowed)* options)#awaited
}
}
}
}
fn retuned(&self) -> Option<proc_macro2::TokenStream> {
let krate = &self.krate;
let (at, step) = self.weighted_crossing()?;
let at_field = step.field.span();
let field = &step.field;
let asked = self.search_options_name();
let takes = self.takes(at);
let fan = respan(quote!(#krate::__private::route::LaneFan), at_field);
let router = respan(
quote!(#krate::__private::route::ScriptWeightedFan<#takes>),
at_field,
);
Some(quote_spanned! {at_field=>
let __ingraph_retuned__: ::core::option::Option<#router> = match (
::core::option::Option::and_then(
::core::option::Option::as_ref(&asked),
#asked::lane_emphasis,
),
#fan::router(&__ingraph_steps__.#field),
) {
(
::core::option::Option::Some(__ingraph_emphasis__),
::core::option::Option::Some(__ingraph_router__),
) => ::core::option::Option::Some(<#router>::with_emphasis(
<#router>::new(<#router>::lanes(__ingraph_router__)),
*__ingraph_emphasis__,
)),
_ => ::core::option::Option::None,
};
if let ::core::option::Option::Some(__ingraph_router__) = __ingraph_retuned__ {
#fan::set_router(
&mut __ingraph_steps__.#field,
::core::option::Option::Some(__ingraph_router__),
);
}
})
}
fn composed(&self) -> Option<proc_macro2::TokenStream> {
let krate = &self.krate;
let at = self.expand_at()?;
let step = &self.steps[at];
let at_field = step.field.span();
let field = &step.field;
let with = {
use syn::ext::IdentExt as _;
quote::format_ident!("with_{}", step.field.unraw(), span = at_field)
};
let asked = self.search_options_name();
let options = self.step_options_name();
let weights = respan(quote!(#krate::__private::retrieve::ArmWeights), at_field);
Some(quote_spanned! {at_field=>
let __ingraph_composed__: ::core::option::Option<#options> = ::core::option::Option::map(
::core::option::Option::and_then(
::core::option::Option::as_ref(&asked),
#asked::arm_weight,
),
|__ingraph_weight__| {
let __ingraph_over__ = #weights::over(
&#weights::with_paraphrase(#weights::new(), *__ingraph_weight__),
::core::option::Option::unwrap_or(
::core::option::Option::and_then(options, |__ingraph_options__| {
::core::option::Option::as_ref(&__ingraph_options__.#field)
}),
&#weights::DEFAULT,
),
);
#options::#with(
match options {
::core::option::Option::Some(__ingraph_options__) => {
::core::clone::Clone::clone(__ingraph_options__)
}
::core::option::Option::None => #options::new(),
},
__ingraph_over__,
)
},
);
let options = match &__ingraph_composed__ {
::core::option::Option::Some(__ingraph_options__) => {
::core::option::Option::Some(__ingraph_options__)
}
::core::option::Option::None => options,
};
})
}
fn canonical_demands(&self) -> Vec<proc_macro2::TokenStream> {
let krate = &self.krate;
let mut demanded: Vec<proc_macro2::TokenStream> = Vec::new();
let mut spell = |step: &StepModel| {
let at_field = step.field.span();
let ty = &step.ty;
let line = respan(quote!(#krate::__private::drive::DefaultServe), at_field);
demanded.push(quote_spanned!(at_field=> #ty: #line));
};
if self.question.is_none()
&& let Some(head) = self.steps.first()
{
spell(head);
}
for step in &self.steps {
if step.answer.is_none() && step.annotation.is_none() {
spell(step);
}
}
demanded
}
fn gate(&self) -> Option<proc_macro2::TokenStream> {
if !self.fanned() {
return None;
}
let krate = &self.krate;
let name = &self.name;
let tower = name.to_string();
let readings = self.fans().map(|(at, step, fan)| {
let at_field = step.field.span();
let field = &step.field;
let takes = self.takes(at);
let seat = quote_spanned!(at_field=> &__ingraph_steps__.#field);
let unfilled = respan(quote!(#krate::__private::retrieve::UnfilledSeat), at_field);
let named = step.field.to_string();
match fan {
Fan::Expand { expander } => {
let road = respan(quote!(#krate::__private::retrieve::Expansion), at_field);
let declared = spelled("e!(#expander));
quote_spanned! {at_field=>
let __ingraph_road__: &#road<#takes> = #seat;
if !#road::is_mounted(__ingraph_road__) {
::std::vec::Vec::push(
&mut __ingraph_unfilled__,
#unfilled::widening(#named, #declared),
);
}
}
}
Fan::Route { router, .. } => {
let router = router.spelled(krate, &takes);
let fan = respan(quote!(#krate::__private::route::LaneFan), at_field);
quote_spanned! {at_field=>
let __ingraph_fan__: &#fan<#router> = #seat;
if let ::core::result::Result::Err(__ingraph_missing__) = #fan::check(__ingraph_fan__) {
::std::vec::Vec::push(
&mut __ingraph_unfilled__,
#unfilled::crossing(#named, __ingraph_missing__),
);
}
}
}
}
});
Some(quote! {
fn check(
__ingraph_steps__: &#name,
) -> ::core::result::Result<(), #krate::__private::retrieve::SeatsUnfilled> {
let mut __ingraph_unfilled__ = ::std::vec::Vec::new();
#(#readings)*
#krate::__private::retrieve::SeatsUnfilled::checked(#tower, __ingraph_unfilled__)
}
})
}
fn refused_with(&self, at: usize, step: &StepModel) -> proc_macro2::TokenStream {
let at_field = step.field.span();
let ty = &step.ty;
let takes = self.takes(at);
let answers = self.flows(at);
if let Some(Fan::Route { router, .. }) = &step.fan {
let krate = &self.krate;
let router = router.spelled(krate, &takes);
let seam = respan(quote!(#krate::__private::route::LaneRouter), at_field);
let sum = respan(quote!(#krate::__private::route::FanError), at_field);
return quote_spanned!(at_field=> #sum<<#router as #seam>::Error>);
}
let face = respan(self.face(step), at_field);
quote_spanned!(at_field=> <#ty as #face<#takes, #answers>>::Error)
}
fn refusing(&self) -> impl Iterator<Item = (usize, &StepModel)> {
self
.steps
.iter()
.enumerate()
.filter(|(_, step)| !matches!(step.fan, Some(Fan::Expand { .. })))
}
fn refusal(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let name = self.error_name();
let arms = self.refusing().map(|(at, step)| {
let variant = Self::variant(step);
let refused_with = self.refused_with(at, step);
let doc = crate::emit::leading(&format!(
"The `{field}` step refused, and this is what it refused with.",
field = step.field,
));
quote! {
#[doc = #doc]
#variant(#refused_with)
}
});
let doc = crate::emit::leading(&format!(
"How [`{name}`]'s walk refuses — ONE ARM PER STEP, carrying that step's own error.\n\nA \
chain of N hops has N error types and one `Result` has one, so the walk answers this sum: \
the arm NAMES the step that refused, and its payload is the very type that step's `Serves` \
impl declared. Nothing is boxed and nothing is erased, so a caller that matched an arm holds \
the error it was going to inspect anyway.",
name = self.name,
));
quote! {
#[doc = #doc]
#vis enum #name {
#(#arms),*
}
}
}
fn rendering(&self) -> proc_macro2::TokenStream {
let name = self.error_name();
let (displayed, debugged, sourced) = if self.refusing().next().is_none() {
(
quote!(match *self {}),
quote!(match *self {}),
quote!(match *self {}),
)
} else {
let displayed = self.refusing().map(|(_, step)| {
let variant = Self::variant(step);
let said = format!(
"the step `{field}` refused the question",
field = step.field
);
quote!(Self::#variant(_) => ::core::fmt::Formatter::write_str(__ingraph_f, #said))
});
let debugged = self.refusing().map(|(_, step)| {
let at_field = step.field.span();
let variant = Self::variant(step);
let printed = variant.to_string();
quote_spanned! {at_field=>
Self::#variant(__ingraph_refused__) => ::core::fmt::DebugTuple::finish(
::core::fmt::DebugTuple::field(
&mut ::core::fmt::Formatter::debug_tuple(__ingraph_f, #printed),
__ingraph_refused__,
),
)
}
});
let sourced = self.refusing().map(|(_, step)| {
let at_field = step.field.span();
let variant = Self::variant(step);
quote_spanned! {at_field=>
Self::#variant(__ingraph_refused__) =>
::core::option::Option::Some(__ingraph_refused__)
}
});
(
quote!(match self { #(#displayed,)* }),
quote!(match self { #(#debugged,)* }),
quote!(match self { #(#sourced,)* }),
)
};
quote! {
impl ::core::fmt::Display for #name {
fn fmt(&self, __ingraph_f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
#displayed
}
}
impl ::core::fmt::Debug for #name {
fn fmt(&self, __ingraph_f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
#debugged
}
}
impl ::core::error::Error for #name {
fn source(&self) -> ::core::option::Option<&(dyn ::core::error::Error + 'static)> {
#sourced
}
}
}
}
fn walk(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let vis = &self.vis;
let question = self.asked();
let answer = self.derived();
let refusal = self.error_name();
let awaited = self.awaited().then(|| quote!(async));
let parameters = self.steps.iter().enumerate().map(|(at, step)| {
let held = held(at, step.field.span());
let ty = &step.ty;
quote!(#held: &mut #ty,)
});
let body = if self.fanned() {
self.fanned_body(&refusal)
} else {
let hops = self
.steps
.iter()
.enumerate()
.map(|(at, step)| self.hop(at, step, &refusal, false));
quote! {
#(#hops)*
::core::result::Result::Ok(__ingraph_answered__)
}
};
let doc = crate::emit::leading(&self.doc());
let options = self.step_options_name();
quote! {
impl #name {
#[doc = #doc]
#[allow(clippy::too_many_arguments)]
#vis #awaited fn walk(
question: #question,
#(#parameters)*
options: ::core::option::Option<&#options>,
) -> ::core::result::Result<#answer, #refusal> {
#body
}
}
}
}
fn fanned_body(&self, refusal: &syn::Ident) -> proc_macro2::TokenStream {
let krate = &self.krate;
let expand_at = self.expand_at();
let route_at = self.route_at();
let Some(opens_at) = expand_at.or(route_at) else {
return quote!(::core::result::Result::Ok(__ingraph_answered__));
};
let ends_at = route_at.unwrap_or(self.steps.len());
let lead = (0..opens_at).map(|at| self.hop(at, &self.steps[at], refusal, false));
let per_arm = expand_at
.map(|at| at + 1..ends_at)
.unwrap_or(0..0)
.map(|at| self.hop(at, &self.steps[at], refusal, true));
let per_cell = route_at
.map(|at| at + 1..self.steps.len())
.unwrap_or(0..0)
.map(|at| self.hop(at, &self.steps[at], refusal, true));
let widening = expand_at.map(|at| self.widening(at, &self.steps[at]));
let crossing = route_at.map(|at| self.crossing(at, &self.steps[at], refusal));
let cell = self.cell(expand_at.is_some(), route_at.is_some());
let fold = self.fold();
let arm_taken = expand_at.map(|at| {
let at_field = self.steps[at].field.span();
let arms = Self::named(&self.steps[at], at_field);
quote_spanned! {at_field=>
let (__ingraph_answered__, __ingraph_origin__) =
#krate::__private::retrieve::Expanded::into_components(__ingraph_widened__);
let __ingraph_arm_weight__ = #krate::__private::retrieve::ArmWeights::weight(
::core::option::Option::unwrap_or(
#arms,
&#krate::__private::retrieve::ArmWeights::DEFAULT,
),
&__ingraph_origin__,
);
}
});
let lane_taken = route_at.map(|at| {
let at_field = self.steps[at].field.span();
let answers = self.answered(&self.steps[at]);
let probe = respan(quote!(#krate::__private::route::RoutedProbe), at_field);
quote_spanned! {at_field=>
let __ingraph_lane__ = #probe::lane(&__ingraph_probe__);
let __ingraph_lane_weight__ = #probe::weight(&__ingraph_probe__);
let __ingraph_answered__: #answers = __ingraph_probe__;
}
});
let mut nested = quote! {
#lane_taken
#(#per_cell)*
#cell
};
if route_at.is_some() {
nested = quote! {
for __ingraph_probe__ in ::core::iter::IntoIterator::into_iter(__ingraph_probes__) {
#nested
}
};
}
nested = quote! {
#(#per_arm)*
#crossing
#nested
};
if expand_at.is_some() {
nested = quote! {
for (__ingraph_arm__, __ingraph_widened__) in ::core::iter::Iterator::enumerate(
::core::iter::IntoIterator::into_iter(__ingraph_family__),
) {
#arm_taken
#nested
}
};
}
quote! {
#(#lead)*
#widening
let mut __ingraph_grid__ = ::std::vec::Vec::new();
#nested
#fold
}
}
fn widening(&self, at: usize, step: &StepModel) -> proc_macro2::TokenStream {
let krate = &self.krate;
let at_field = step.field.span();
let held = held(at, at_field);
let takes = self.takes(at);
let answers = self.answered(step);
let taken = if at == 0 {
quote_spanned!(at_field=> question)
} else {
quote_spanned!(at_field=> __ingraph_answered__)
};
let seat = respan(quote!(#krate::__private::retrieve::Expansion), at_field);
let widened = respan(quote!(#krate::__private::retrieve::Expanded), at_field);
quote_spanned! {at_field=>
let __ingraph_asked__: #takes = #taken;
let __ingraph_road__: &#seat<#takes> = #held;
let __ingraph_family__: ::std::vec::Vec<#widened<#answers>> =
#seat::expand(__ingraph_road__, __ingraph_asked__).await;
}
}
fn crossing(
&self,
at: usize,
step: &StepModel,
refusal: &syn::Ident,
) -> proc_macro2::TokenStream {
let krate = &self.krate;
let at_field = step.field.span();
let held = held(at, at_field);
let takes = self.takes(at);
let variant = Self::variant(step);
let taken = if at == 0 {
quote_spanned!(at_field=> question)
} else {
quote_spanned!(at_field=> __ingraph_answered__)
};
let Some(Fan::Route { router, .. }) = &step.fan else {
return quote!();
};
let router = router.spelled(krate, &takes);
let seat = respan(quote!(#krate::__private::route::LaneFan), at_field);
quote_spanned! {at_field=>
let __ingraph_asked__: #takes = #taken;
let __ingraph_fan__: &#seat<#router> = #held;
let __ingraph_probes__ = match #seat::route(__ingraph_fan__, &__ingraph_asked__) {
::core::result::Result::Ok(__ingraph_probes__) => __ingraph_probes__,
::core::result::Result::Err(__ingraph_refused__) => {
return ::core::result::Result::Err(#refusal::#variant(__ingraph_refused__));
}
};
}
}
fn cell(&self, widens: bool, crosses: bool) -> proc_macro2::TokenStream {
let krate = &self.krate;
let at_field = self
.steps
.last()
.map_or_else(proc_macro2::Span::call_site, |step| step.field.span());
let stream = respan(quote!(#krate::__private::retrieve::FanStream), at_field);
let ranked = respan(quote!(#krate::__private::retrieve::RankedStream), at_field);
let found = quote_spanned!(at_field=> #ranked::into_ranked(__ingraph_answered__));
let built = match (widens, crosses) {
(true, true) => quote_spanned!(at_field=> #stream::new(
__ingraph_lane__,
__ingraph_arm__,
__ingraph_arm_weight__,
__ingraph_lane_weight__,
#found,
)),
(true, false) => {
quote_spanned!(at_field=> #stream::uncut(__ingraph_arm__, __ingraph_arm_weight__, #found))
}
(false, true) => quote_spanned!(at_field=>
#stream::unwidened(__ingraph_lane__, __ingraph_lane_weight__, #found)
),
(false, false) => return quote!(),
};
quote_spanned!(at_field=> ::std::vec::Vec::push(&mut __ingraph_grid__, #built);)
}
fn fold(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let at_field = self
.steps
.last()
.map_or_else(proc_macro2::Span::call_site, |step| step.field.span());
let tail = self.tail();
let stream = respan(quote!(#krate::__private::retrieve::RankedStream), at_field);
let root = quote_spanned!(at_field=> <#tail as #stream>::Root);
let evidence = quote_spanned!(at_field=> <#tail as #stream>::Evidence);
let join = respan(quote!(#krate::__private::retrieve::HashJoin), at_field);
let fold = respan(quote!(#krate::__private::retrieve::fuse_fanned), at_field);
let fusion = respan(quote!(#krate::__private::retrieve::Fusion), at_field);
quote_spanned! {at_field=>
::core::result::Result::Ok(#fold::<#root, #evidence, #join<#root>>(
__ingraph_grid__,
#fusion::rrf(),
))
}
}
fn hop(
&self,
at: usize,
step: &StepModel,
refusal: &syn::Ident,
reborrowed: bool,
) -> proc_macro2::TokenStream {
if step.annotation.is_some() {
return self.annotating(at, step, refusal, reborrowed);
}
let at_field = step.field.span();
let held = held(at, at_field);
let held = if reborrowed {
quote_spanned!(at_field=> &mut *#held)
} else {
quote_spanned!(at_field=> #held)
};
let takes = self.takes(at);
let answers = self.answered(step);
let face = respan(self.face(step), at_field);
let variant = Self::variant(step);
let taken = if at == 0 {
quote_spanned!(at_field=> question)
} else {
quote_spanned!(at_field=> __ingraph_answered__)
};
let landed = step.awaited.then(|| quote_spanned!(at_field=> .await));
let named = Self::named(step, at_field);
quote_spanned! {at_field=>
let __ingraph_asked__: #takes = #taken;
let __ingraph_answered__: #answers = match #face::serve(
#held,
__ingraph_asked__,
#named,
)
#landed
{
::core::result::Result::Ok(__ingraph_answered__) => __ingraph_answered__,
::core::result::Result::Err(__ingraph_refused__) => {
return ::core::result::Result::Err(#refusal::#variant(__ingraph_refused__));
}
};
}
}
fn annotating(
&self,
at: usize,
step: &StepModel,
refusal: &syn::Ident,
reborrowed: bool,
) -> proc_macro2::TokenStream {
let krate = &self.krate;
let at_field = step.field.span();
let held = held(at, at_field);
let held = if reborrowed {
quote_spanned!(at_field=> &mut *#held)
} else {
quote_spanned!(at_field=> #held)
};
let takes = self.takes(at);
let face = respan(self.face(step), at_field);
let seam = respan(
quote!(#krate::__private::retrieve::AnnotatedQuestion),
at_field,
);
let variant = Self::variant(step);
let taken = if at == 0 {
quote_spanned!(at_field=> question)
} else {
quote_spanned!(at_field=> __ingraph_answered__)
};
let landed = step.awaited.then(|| quote_spanned!(at_field=> .await));
let named = Self::named(step, at_field);
let annotation = step.annotation.as_ref();
quote_spanned! {at_field=>
let __ingraph_asked__: #takes = #taken;
let __ingraph_told__ = ::core::option::Option::is_some(
&<#takes as #seam<#annotation>>::carried(&__ingraph_asked__),
);
let __ingraph_answered__: #takes = if __ingraph_told__ {
__ingraph_asked__
} else {
match #face::serve(
#held,
__ingraph_asked__,
#named,
)
#landed
{
::core::result::Result::Ok(__ingraph_answered__) => __ingraph_answered__,
::core::result::Result::Err(__ingraph_refused__) => {
return ::core::result::Result::Err(#refusal::#variant(__ingraph_refused__));
}
}
};
}
}
fn named(step: &StepModel, at_field: proc_macro2::Span) -> proc_macro2::TokenStream {
let field = &step.field;
quote_spanned! {at_field=>
::core::option::Option::and_then(options, |__ingraph_options__| {
::core::option::Option::as_ref(&__ingraph_options__.#field)
})
}
}
fn written(step: &StepModel, seat: &str) -> String {
let ty = &step.ty;
format!("<{} as DefaultServe>::{seat}", spelled("e!(#ty)))
}
fn doc(&self) -> String {
let chain = self
.steps
.iter()
.map(|step| {
let ty = &step.ty;
format!(
"| `{field}` | `{ty}` | {face} | `{answer}` |",
field = step.field,
ty = spelled("e!(#ty)),
face = if step.awaited { "awaited" } else { "blocking" },
answer = step.answer.as_ref().map_or_else(
|| Self::written(step, "Answer"),
|answer| spelled("e!(#answer)),
),
)
})
.collect::<Vec<_>>()
.join("\n");
let asked = match (&self.question, self.steps.first()) {
(Some(question), _) => spelled("e!(#question)),
(None, Some(head)) => Self::written(head, "Question"),
(None, None) => "()".to_owned(),
};
format!(
"Walk this tower — [`{name}`]'s question pipeline, from `{question}` to `{answer}` in one \
{face}function.\n\nThe question comes FIRST, then one `&mut` borrow per step in declaration \
order, then [`{options}`]({options}) — the tower's own options, out of which each hop is \
handed ITS OWN field. The face is {face}because {why} — the OR law.\n\n| step | server | \
face | answers |\n|---|---|---|---|\n{chain}\n\nA hop this call named nothing for is served \
under `None` and runs at its own floor, and `None` for the whole seat names nothing for any \
of them.\n\n# Errors\n\nThe step that refused, as the arm of [`{error}`]({error}) named \
after it.",
name = self.name,
error = self.error_name(),
options = self.step_options_name(),
question = asked,
answer = self.steps.last().map_or_else(
|| "()".to_owned(),
|step| step.answer.as_ref().map_or_else(
|| Self::written(step, "Answer"),
|answer| spelled("e!(#answer)),
),
),
face = if self.awaited() {
"awaited "
} else {
"blocking "
},
why = if self.awaited() {
"at least one step is awaited"
} else {
"every step is blocking"
},
)
}
}
fn spelled(tokens: &proc_macro2::TokenStream) -> String {
tokens
.to_string()
.replace(" < ", "<")
.replace(" >", ">")
.replace(" :: ", "::")
.replace(" , ", ", ")
}
fn held(at: usize, at_field: proc_macro2::Span) -> syn::Ident {
quote::format_ident!("__ingraph_step{at}__", span = at_field)
}