use proc_macro2::TokenStream;
use quote::{ToTokens as _, quote};
#[cfg(test)]
mod tests;
pub const RESERVED: &[&str] = &[
"AMBIGUOUS_PAGE_DIRECTION",
"OVERSIZED_SKIP",
"REPEATED_ORDER_SUBJECT",
"REQUEST_DROPPED",
"REQUEST_TIMED_OUT",
"STORE_REFUSED",
"UNPAGEABLE_ORDER",
"UNREACHABLE_NODE",
"UNREACHABLE_SOURCE",
"UNREADABLE_ROW",
"UNRENDERABLE_ORDER",
"UNSUPPORTED_FILTER",
"UNUSABLE_ADDRESS",
"UNUSABLE_CURSOR",
"UNWRITTEN_ARTIFACT",
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ErrorRoad {
Mutation,
Query,
}
impl ErrorRoad {
#[must_use]
pub const fn word(self) -> &'static str {
match self {
Self::Mutation => "mutation_error",
Self::Query => "query_error",
}
}
#[must_use]
pub const fn subject(self) -> &'static str {
match self {
Self::Mutation => "a declared exchange's failure",
Self::Query => "a read path's failure",
}
}
}
#[derive(Debug, Clone)]
pub struct ErrorModel {
pub name: syn::Ident,
pub road: ErrorRoad,
pub variants: Vec<VariantModel>,
}
#[derive(Debug, Clone)]
pub struct VariantModel {
pub name: syn::Ident,
pub code: syn::LitStr,
pub rendering: Rendering,
pub shape: VariantShape,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VariantShape {
Unit,
Tuple,
Named,
}
#[derive(Debug, Clone)]
pub struct Rendering {
pub template: String,
pub bound: Vec<Binding>,
}
#[derive(Debug, Clone)]
pub struct Binding {
pub held: syn::Ident,
pub at: BindingAt,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BindingAt {
Position(usize),
Named(syn::Ident),
}
impl ErrorModel {
#[must_use]
pub fn emit(&self) -> TokenStream {
let name = &self.name;
let display = self.display();
let coded = self.coded();
let doc = crate::emit::leading(&format!(
"The word this failure is recognised by — the head of everything it renders as.\n\nOne per \
variant and never absent, which is what `#[ingraph::{word}]` checks: {subject} whose \
variants shared a word would tell a client one thing about two mistakes.",
word = self.road.word(),
subject = self.road.subject(),
));
quote! {
impl ::core::fmt::Display for #name {
fn fmt(&self, __ingraph_f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
#display
}
}
impl ::core::error::Error for #name {}
impl #name {
#[doc = #doc]
#[must_use]
pub const fn code(&self) -> &'static str {
#coded
}
}
}
}
fn display(&self) -> TokenStream {
if self.variants.is_empty() {
return quote!(match *self {});
}
let arms = self.variants.iter().map(|variant| {
let pattern = variant.pattern();
let template = &variant.rendering.template;
if variant.rendering.bound.is_empty() {
return quote!(#pattern => ::core::fmt::Formatter::write_str(__ingraph_f, #template));
}
let arguments = variant.rendering.bound.iter().map(|binding| {
let held = &binding.held;
quote!(#held = #held)
});
quote!(#pattern => ::core::write!(__ingraph_f, #template, #(#arguments),*))
});
quote!(match self { #(#arms,)* })
}
fn coded(&self) -> TokenStream {
if self.variants.is_empty() {
return quote!(match *self {});
}
let arms = self.variants.iter().map(|variant| {
let pattern = variant.blind();
let code = &variant.code;
quote!(#pattern => #code)
});
quote!(match self { #(#arms,)* })
}
}
impl VariantModel {
fn pattern(&self) -> TokenStream {
let name = &self.name;
match self.shape {
VariantShape::Unit => quote!(Self::#name),
VariantShape::Named => {
let held = self.rendering.bound.iter().map(|binding| {
let BindingAt::Named(at) = &binding.at else {
return TokenStream::new();
};
let held = &binding.held;
quote!(#at: #held,)
});
quote!(Self::#name { #(#held)* .. })
}
VariantShape::Tuple => {
let width = self
.rendering
.bound
.iter()
.filter_map(|binding| match &binding.at {
BindingAt::Position(at) => Some(at + 1),
BindingAt::Named(_) => None,
})
.max()
.unwrap_or(0);
let held = (0..width).map(|at| {
self
.rendering
.bound
.iter()
.find(|binding| binding.at == BindingAt::Position(at))
.map_or_else(|| quote!(_), |binding| binding.held.to_token_stream())
});
quote!(Self::#name(#(#held,)* ..))
}
}
}
fn blind(&self) -> TokenStream {
let name = &self.name;
match self.shape {
VariantShape::Unit => quote!(Self::#name),
VariantShape::Tuple => quote!(Self::#name(..)),
VariantShape::Named => quote!(Self::#name { .. }),
}
}
}