pdb-bindgen-codegen 0.1.0

Build-time discovery, PDB acquisition, and binding generation for pdb-bindgen.
Documentation
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",
        )
    })
}