pdb-bindgen-codegen 0.1.0

Build-time discovery, PDB acquisition, and binding generation for pdb-bindgen.
Documentation
mod ast;
mod diagnostic;
mod environment;
mod graph;
mod manifest;
mod model;
mod predicate;
mod source;

pub(crate) use diagnostic::{Diagnostic, DiagnosticCategory};
use model::SourceFile;
pub(crate) use model::{
    Discovery, ResolvedItem, ResolvedItemKind, SelectedField, SymbolDeclaration, SymbolFunction,
    SymbolGlobal, SymbolSafety, TypeSyntax,
};

#[cfg(test)]
pub(crate) use model::{DiscoveredItemKind, ImageScope, Location, ModuleBody, SymbolArgument};

use crate::Builder;
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::fs;
use std::path::{Path, PathBuf};
use syn::spanned::Spanned as _;

use self::ast::walk_items;
use self::environment::build_cfg;
use self::predicate::effective_metas;
use self::source::collect_root;

pub(crate) fn discover(
    package_root: &Path,
    builder: &Builder,
    environment: impl IntoIterator<Item = (OsString, OsString)>,
) -> Result<Discovery, Diagnostic> {
    let package = fs::canonicalize(package_root).map_err(|error| {
        Diagnostic::io(
            DiagnosticCategory::PackageRoot,
            ".",
            "cannot resolve package root",
            error,
        )
    })?;
    if !package.is_dir() {
        return Err(Diagnostic::new(
            DiagnosticCategory::PackageRoot,
            ".",
            "package root is not a directory",
        ));
    }
    let environment = environment.into_iter().collect::<Vec<_>>();
    let cfg = build_cfg(&package, builder, &environment)?;
    let roots = if builder.source_roots().len() == 0 {
        vec![PathBuf::from("src")]
    } else {
        builder.source_roots().map(Path::to_path_buf).collect()
    };
    let mut files = BTreeMap::<String, PathBuf>::new();
    for root in roots {
        collect_root(&package, &root, &mut files)?;
    }
    let mut discovered_files = Vec::new();
    for (local, path) in files {
        let bytes = fs::read(&path).map_err(|error| {
            Diagnostic::io(
                DiagnosticCategory::Io,
                &local,
                "cannot read Rust source",
                error,
            )
        })?;
        let source = String::from_utf8(bytes).map_err(|_| {
            Diagnostic::new(DiagnosticCategory::Utf8, &local, "Rust source is not UTF-8")
        })?;
        let file = syn::parse_file(&source).map_err(|error| {
            Diagnostic::at(
                DiagnosticCategory::RustSyntax,
                &local,
                error.span(),
                error.to_string(),
            )
        })?;
        let file_attrs = effective_metas(&file.attrs, &cfg, &local)?;
        if !file_attrs.active {
            continue;
        }
        if !file_attrs.markers.is_empty() {
            return Err(Diagnostic::at(
                DiagnosticCategory::Marker,
                &local,
                file_attrs.markers[0].span(),
                "#[pdb] is not allowed as a file attribute",
            ));
        }
        let items = walk_items(&file.items, &cfg, &local)?;
        discovered_files.push(SourceFile { path: local, items });
    }
    let resolved = graph::resolve(&discovered_files, builder)?;
    Ok(Discovery {
        files: discovered_files,
        resolved,
    })
}