use super::diagnostic::{Diagnostic, DiagnosticCategory};
use super::environment::CfgSet;
use syn::parse::Parser as _;
use syn::punctuated::Punctuated;
use syn::spanned::Spanned as _;
use syn::{Attribute, Expr, Lit, Meta, Token};
pub(super) struct EffectiveMetas {
pub(super) active: bool,
pub(super) markers: Vec<Meta>,
pub(super) paths: Vec<Meta>,
pub(super) attributes: Vec<Meta>,
}
pub(super) fn effective_metas(
attrs: &[Attribute],
cfg: &CfgSet,
path: &str,
) -> Result<EffectiveMetas, Diagnostic> {
let mut result = EffectiveMetas {
active: true,
markers: Vec::new(),
paths: Vec::new(),
attributes: Vec::new(),
};
for attr in attrs {
process_meta(&attr.meta, cfg, path, &mut result)?;
if !result.active {
break;
}
}
Ok(result)
}
fn process_meta(
meta: &Meta,
cfg: &CfgSet,
path: &str,
result: &mut EffectiveMetas,
) -> Result<(), Diagnostic> {
if meta.path().is_ident("cfg") {
let Meta::List(list) = meta else {
return Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
meta.span(),
"cfg requires one predicate",
));
};
let predicate = syn::parse2::<Meta>(list.tokens.clone()).map_err(|error| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
error.span(),
error.to_string(),
)
})?;
result.active = eval_cfg(&predicate, cfg, path)?;
} else if meta.path().is_ident("cfg_attr") {
let Meta::List(list) = meta else {
return Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
meta.span(),
"cfg_attr requires a predicate and attributes",
));
};
let values = Punctuated::<Meta, Token![,]>::parse_terminated
.parse2(list.tokens.clone())
.map_err(|error| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
error.span(),
error.to_string(),
)
})?;
let mut values = values.into_iter();
let predicate = values.next().ok_or_else(|| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
list.span(),
"cfg_attr requires a predicate and attributes",
)
})?;
let generated = values.collect::<Vec<_>>();
if generated.is_empty() {
return Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
list.span(),
"cfg_attr requires at least one attribute",
));
}
if eval_cfg(&predicate, cfg, path)? {
for generated in &generated {
process_meta(generated, cfg, path, result)?;
if !result.active {
break;
}
}
}
} else if meta.path().is_ident("path") {
result.paths.push(meta.clone());
} else if meta
.path()
.segments
.last()
.is_some_and(|segment| segment.ident == "pdb")
{
result.markers.push(meta.clone());
} else {
result.attributes.push(meta.clone());
}
Ok(())
}
fn eval_cfg(meta: &Meta, cfg: &CfgSet, path: &str) -> Result<bool, Diagnostic> {
match meta {
Meta::Path(atom) => Ok(cfg.flags.contains(&cfg_name(atom, path)?)),
Meta::NameValue(pair) => {
let name = cfg_name(&pair.path, path)?;
let Expr::Lit(expression) = &pair.value else {
return Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
pair.value.span(),
"cfg values must be string literals",
));
};
let Lit::Str(value) = &expression.lit else {
return Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
expression.lit.span(),
"cfg values must be string literals",
));
};
Ok(cfg
.values
.get(&name)
.is_some_and(|values| values.contains(&value.value())))
}
Meta::List(list) => {
let operator = list
.path
.get_ident()
.map(ToString::to_string)
.ok_or_else(|| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
list.path.span(),
"unsupported cfg predicate",
)
})?;
let values = Punctuated::<Meta, Token![,]>::parse_terminated
.parse2(list.tokens.clone())
.map_err(|error| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
error.span(),
error.to_string(),
)
})?
.into_iter()
.collect::<Vec<_>>();
match operator.as_str() {
"all" => {
let mut result = true;
for value in &values {
result &= eval_cfg(value, cfg, path)?;
}
Ok(result)
}
"any" => {
let mut result = false;
for value in &values {
result |= eval_cfg(value, cfg, path)?;
}
Ok(result)
}
"not" if values.len() == 1 => Ok(!eval_cfg(&values[0], cfg, path)?),
"not" => Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
list.span(),
"not requires exactly one predicate",
)),
_ => Err(Diagnostic::at(
DiagnosticCategory::Cfg,
path,
list.path.span(),
"unsupported cfg predicate",
)),
}
}
}
}
fn cfg_name(name: &syn::Path, path: &str) -> Result<String, Diagnostic> {
name.get_ident().map(ToString::to_string).ok_or_else(|| {
Diagnostic::at(
DiagnosticCategory::Cfg,
path,
name.span(),
"cfg atom names must be one Rust identifier",
)
})
}