use std::collections::BTreeMap;
use ingraph_codegen::union::{self, Face, UnionMember};
use quote::ToTokens as _;
use crate::{attribute, errors::Errors};
pub(crate) const UNWRAP_ERROR: &str = "unwrap_error";
const RENAMED: &str = "`error` names CONVERSION CELLS now — the unwrap refusal's knob is \
`unwrap_error(rename = \"…\")`. One word per thing typed: a cell says what a \
fallible crossing refuses with, and this says what a wrong-variant unwrap \
answers with";
pub(crate) fn refusal_knob(
meta: &syn::meta::ParseNestedMeta<'_>,
slot: &mut Option<syn::Ident>,
errors: &mut Errors,
) -> Option<syn::Result<()>> {
if meta.path.is_ident(UNWRAP_ERROR) {
return Some(attribute::rename_block(meta, slot, UNWRAP_ERROR, errors));
}
if meta.path.is_ident("error") {
errors.push(attribute::unknown(meta, RENAMED, &[]));
return Some(Ok(()));
}
None
}
pub(crate) struct Family {
pub(crate) derive: &'static str,
pub(crate) noun: &'static str,
pub(crate) possessive: &'static str,
pub(crate) not_an_enum: &'static str,
pub(crate) empty: &'static str,
pub(crate) several: &'static str,
pub(crate) positional: &'static str,
pub(crate) variant_entry: &'static str,
pub(crate) duplicate: &'static str,
pub(crate) generic: &'static str,
}
pub(crate) fn concrete(family: &Family, generics: &syn::Generics, errors: &mut Errors) {
let why = format!(
"generic {noun}s are not supported — {generic}",
noun = family.noun,
generic = family.generic
);
if !generics.params.is_empty() {
errors.push(syn::Error::new_spanned(generics, why));
} else if let Some(clause) = &generics.where_clause {
errors.push(syn::Error::new_spanned(clause, why));
}
}
pub(crate) fn members(
family: &Family,
input: &syn::DeriveInput,
errors: &mut Errors,
) -> syn::Result<Vec<UnionMember>> {
let syn::Data::Enum(data) = &input.data else {
return Err(syn::Error::new_spanned(
&input.ident,
format!(
"`{derive}` supports enums only — {not_an_enum}",
derive = family.derive,
not_an_enum = family.not_an_enum
),
));
};
if data.variants.is_empty() {
return Err(syn::Error::new_spanned(
&input.ident,
format!(
"an enum with no variants declares no {noun} — {empty}",
noun = family.noun,
empty = family.empty
),
));
}
let mut parsed = Vec::with_capacity(data.variants.len());
for variant in &data.variants {
bare(family, &variant.attrs, errors);
match &variant.fields {
syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => parsed.push(UnionMember {
ident: variant.ident.clone(),
ty: fields
.unnamed
.first()
.expect("a one-field list has a first field")
.ty
.clone(),
}),
syn::Fields::Unnamed(fields) if fields.unnamed.is_empty() => {
errors.push(carries_nothing(family, &variant.ident, &variant.fields));
}
syn::Fields::Unnamed(fields) => errors.push(syn::Error::new_spanned(
&variant.fields,
format!(
"`{derive}` takes ONE member per variant — `{ident}` carries {carried}. \
{several}",
derive = family.derive,
ident = variant.ident,
carried = fields.unnamed.len(),
several = family.several,
),
)),
syn::Fields::Named(_) => errors.push(syn::Error::new_spanned(
&variant.fields,
format!(
"`{derive}` takes the member POSITIONALLY — `{ident}` names its payload. \
{positional} Write `{ident}(…)`",
derive = family.derive,
ident = variant.ident,
positional = family.positional,
),
)),
syn::Fields::Unit => errors.push(carries_nothing(family, &variant.ident, &variant.ident)),
}
}
Ok(parsed)
}
fn carries_nothing(family: &Family, ident: &syn::Ident, at: impl quote::ToTokens) -> syn::Error {
let unwrap = Face::Unwrap.name(&union::word(ident));
syn::Error::new_spanned(
at,
format!(
"`{derive}` takes variants that CARRY their member — `{ident}` carries none. \
{possessive} variant IS one member type, so the payload is the whole of what the variant is \
for: one with none names no member, and `{unwrap}` would have nothing to hand back. A \
variant that is only a NAME is a vocabulary's, which `#[derive(ingraph::Enum)]` describes",
derive = family.derive,
possessive = family.possessive,
),
)
}
fn bare(family: &Family, attrs: &[syn::Attribute], errors: &mut Errors) {
let why = format!(
"unknown entry in `#[ingraph(…)]` on a {noun}'s variant — {variant_entry}",
noun = family.noun,
variant_entry = family.variant_entry
);
attribute::walk(attrs, errors, |meta, errors| {
errors.push(attribute::unknown(&meta, &why, &[]));
Ok(())
});
}
pub(crate) fn collisions(family: &Family, members: &[UnionMember], errors: &mut Errors) {
let mut carried: BTreeMap<String, &syn::Ident> = BTreeMap::new();
for member in members {
let ty = member.ty.to_token_stream().to_string();
if let Some(first) = carried.get(&ty) {
errors.push(syn::Error::new_spanned(
&member.ident,
format!(
"`{ident}` and `{first}` carry ONE member type — {duplicate}",
ident = member.ident,
duplicate = family.duplicate,
),
));
} else {
carried.insert(ty, &member.ident);
}
}
let mut words: BTreeMap<String, &syn::Ident> = BTreeMap::new();
for member in members {
let word = member.word().to_string();
if let Some(first) = words.get(&word) {
errors.push(syn::Error::new_spanned(
&member.ident,
format!(
"`{}` and `{first}` both derive `{}` — the emitted face would be two methods of one \
name, seven times over",
member.ident,
Face::Predicate.name(&member.word())
),
));
} else {
words.insert(word, &member.ident);
}
}
}