clang_parser.rs

//! Invokes Clang as the C++ frontend and converts its AST dump into a schema.

use crate::schema::Schema;
use std::fs;
use std::process::Command;

/// Options that must match the compilation environment of the parsed header.
#[derive(Debug, Clone)]
pub struct ClangOptions {
    /// Clang-compatible frontend executable, such as `clang` or `clang++`.
    pub executable: String,
    /// Language standard without the `-std=` prefix.
    pub standard: String,
    /// Include paths, defines, target options, sysroot, and other project flags.
    pub extra_args: Vec<String>,
}

impl Default for ClangOptions {
    fn default() -> Self {
        Self {
            executable: "clang".to_string(),
            standard: "c++20".to_string(),
            extra_args: Vec::new(),
        }
    }
}

pub fn generate_clang_ast_dump(header_path: &str) -> Result<String, String> {
    generate_clang_ast_dump_with_options(header_path, &ClangOptions::default())
}

/// Parses a header with Clang and returns the complete JSON AST dump.
pub fn generate_clang_ast_dump_with_options(
    header_path: &str,
    options: &ClangOptions,
) -> Result<String, String> {
    let canonical = fs::canonicalize(header_path)
        .map_err(|e| format!("Failed to read header {}: {}", header_path, e))?;

    let mut command = Command::new(&options.executable);
    command.args([
        "-x",
        "c++",
        &format!("-std={}", options.standard),
        "-fsyntax-only",
    ]);
    // Project arguments precede the input so Clang applies them to the header.
    command.args(&options.extra_args);
    command.args(["-Xclang", "-ast-dump=json"]);
    command.arg(&canonical);

    let output = command
        .output()
        .map_err(|e| format!("Failed to invoke {}: {}", options.executable, e))?;

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr);
        return Err(format!("clang parse failed for {}: {}", header_path, err));
    }

    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}

pub fn parse_header_with_clang(header_path: &str) -> Result<Schema, String> {
    parse_header_with_clang_options(header_path, &ClangOptions::default())
}

/// Parses a header and projects declarations owned by that header into a schema.
pub fn parse_header_with_clang_options(
    header_path: &str,
    options: &ClangOptions,
) -> Result<Schema, String> {
    let ast_json = generate_clang_ast_dump_with_options(header_path, options)?;
    Ok(Schema::parse_clang_ast_json_for_file(
        &ast_json,
        header_path,
    ))
}