use quote::ToTokens;
pub(super) fn normalized_literal_value(expression: &syn::Expr) -> String {
match expression {
syn::Expr::Call(call) if is_some_call(call) && call.args.len() == 1 => {
normalized_literal_value(&call.args[0])
}
syn::Expr::Reference(reference)
if matches!(reference.expr.as_ref(), syn::Expr::Array(_)) =>
{
normalized_literal_value(&reference.expr)
}
syn::Expr::Array(array) => {
let elements = array
.elems
.iter()
.map(normalized_literal_value)
.collect::<Vec<_>>();
format!("[{}]", elements.join(", "))
}
syn::Expr::Struct(literal) if path_ends_with(&literal.path, "LocalizedText") => {
let fields = literal
.fields
.iter()
.map(|field| {
let member = field.member.to_token_stream();
let value = normalized_literal_value(&field.expr);
format!("{member}: {value}")
})
.collect::<Vec<_>>();
format!("{{{}}}", fields.join(", "))
}
syn::Expr::Struct(literal) if path_ends_with(&literal.path, "RequirementSpec") => {
let named = |wanted: &str| {
literal
.fields
.iter()
.find(
|field| matches!(&field.member, syn::Member::Named(name) if name == wanted),
)
.map(|field| normalized_literal_value(&field.expr))
};
match (named("capability"), named("provider")) {
(Some(capability), Some(provider)) => format!("{capability} => {provider}"),
_ => expression.to_token_stream().to_string(),
}
}
value => value.to_token_stream().to_string(),
}
}
fn is_some_call(call: &syn::ExprCall) -> bool {
matches!(&*call.func, syn::Expr::Path(path) if path.path.is_ident("Some"))
}
fn path_ends_with(path: &syn::Path, name: &str) -> bool {
path.segments
.last()
.is_some_and(|segment| segment.ident == name)
}