buildlang 1.15.0

BuildLang (buildc): an effects-oriented compiler with a verified C path, shader output, experimental backends, opt-in linear types, and re-checkable accountability + scientific-runtime receipts
Documentation
mod model;
#[cfg(test)]
mod tests;
mod util;
mod validate;

use std::collections::BTreeSet;
use std::path::Path;

use buildlang::lexer::{Lexer, SourceFile};
use buildlang::parser::Parser;

pub(crate) use model::ModuleGraphReceipt;
use model::{
    ModuleGraphDigest, ModuleGraphEdge, ModuleGraphInput, ModuleGraphModel, ModuleGraphProgram,
    ModuleGraphSourceSet, ModuleGraphSummary, ProgramDigestProjection,
};
use util::{
    corpus_relative_path, digest_hex, module_digest, sorted, validate_corpus_relative_path,
};
#[allow(unused_imports)]
pub(crate) use validate::{validate_module_graph_receipt, verify_module_graph_receipt};

use super::{
    input_graph_digest, preprocess_includes_recording_inputs, resolve_imports_recording_inputs,
    resolve_modules_recording_inputs, source_text_digest_hex, CheckReceiptInputDigest,
    InputDigestLedger, SemanticCorpusManifest, SemanticCorpusProgram,
};

pub(crate) const MODULE_GRAPH_RECEIPT: &str = "module-graph-2026-06-18.json";
pub(super) const MODULE_GRAPH_SCHEMA: &str = "buildlang-module-graph-receipt/v0";

fn program_known_gaps() -> Vec<String> {
    sorted(
        [
            "full name resolution is not claimed",
            "package public API graph is not claimed",
        ]
        .into_iter()
        .map(str::to_string)
        .collect(),
    )
}

fn summary_known_gaps() -> Vec<String> {
    sorted(
        [
            "cross-package public API index",
            "full LSP navigation readiness",
            "package registry dependency graph",
        ]
        .into_iter()
        .map(str::to_string)
        .collect(),
    )
}

fn module_model() -> ModuleGraphModel {
    ModuleGraphModel {
        resolver: "buildc source input resolver".to_string(),
        input_roles: vec![
            "entry".to_string(),
            "include".to_string(),
            "import".to_string(),
            "module".to_string(),
        ],
        digest_anchor: "buildlang-check-receipt/v1 input_graph_digest".to_string(),
        symbol_anchor: format!("receipts/{}", crate::symbol_graph::SYMBOL_GRAPH_RECEIPT),
    }
}

fn edge_kind(role: &str) -> Result<&'static str, String> {
    match role {
        "entry" => Ok("program_entry"),
        "include" => Ok("program_include"),
        "import" => Ok("program_import"),
        "module" => Ok("program_module"),
        other => Err(format!("module graph unsupported input role '{other}'")),
    }
}

fn program_digest(program: &ModuleGraphProgram) -> Result<ModuleGraphDigest, String> {
    let projection = ProgramDigestProjection {
        id: &program.id,
        path: &program.path,
        source_digest_hex: &program.source_digest.hex,
        input_graph_digest_hex: &program.input_graph_digest.hex,
        inputs: &program.inputs,
        edges: &program.edges,
        known_gaps: &program.known_gaps,
    };
    serde_json::to_vec(&projection)
        .map(|bytes| module_digest(digest_hex(&bytes)))
        .map_err(|err| format!("module graph failed to encode program digest projection: {err}"))
}

fn source_records(
    program_path: &Path,
) -> Result<(ModuleGraphDigest, Vec<CheckReceiptInputDigest>), String> {
    let entry_bytes = std::fs::read(program_path).map_err(|err| {
        format!(
            "module graph failed to read {}: {err}",
            program_path.display()
        )
    })?;
    let source_digest = module_digest(source_text_digest_hex(&entry_bytes));
    let source = String::from_utf8(entry_bytes).map_err(|err| {
        format!(
            "module graph failed to read UTF-8 source {}: {err}",
            program_path.display()
        )
    })?;
    let base_dir = program_path.parent().unwrap_or_else(|| Path::new("."));
    let mut ledger = InputDigestLedger::text_normalized();
    ledger.record("entry", program_path, source.as_bytes());
    let source =
        resolve_imports_recording_inputs(&source, program_path, &mut ledger).map_err(|_| {
            format!(
                "module graph failed to resolve imports for {}",
                program_path.display()
            )
        })?;
    let source =
        preprocess_includes_recording_inputs(&source, base_dir, &mut ledger).map_err(|_| {
            format!(
                "module graph failed to preprocess includes for {}",
                program_path.display()
            )
        })?;
    let source_file = SourceFile::new(program_path.to_string_lossy(), source);
    let mut lexer = Lexer::new(&source_file);
    let tokens = lexer.tokenize().map_err(|err| {
        format!(
            "module graph lexer error in {}: {err}",
            program_path.display()
        )
    })?;
    let mut parser = Parser::new(&source_file, tokens);
    let mut ast = parser.parse().map_err(|err| {
        format!(
            "module graph parse error in {}: {err}",
            program_path.display()
        )
    })?;
    resolve_modules_recording_inputs(&mut ast, base_dir, &mut ledger).map_err(|_| {
        format!(
            "module graph failed to resolve modules for {}",
            program_path.display()
        )
    })?;
    Ok((source_digest, ledger.into_sorted_records()))
}

fn build_inputs(
    root: &Path,
    records: Vec<CheckReceiptInputDigest>,
) -> Result<Vec<ModuleGraphInput>, String> {
    records
        .into_iter()
        .map(|record| {
            let relative = corpus_relative_path(root, Path::new(&record.source), "input.path")?;
            Ok(ModuleGraphInput {
                id: format!("input:{}:{relative}", record.role),
                role: record.role,
                path: relative,
                source_digest: module_digest(record.digest.hex),
            })
        })
        .collect()
}

fn build_edges(
    program_id: &str,
    inputs: &[ModuleGraphInput],
) -> Result<Vec<ModuleGraphEdge>, String> {
    let mut edges = inputs
        .iter()
        .map(|input| {
            Ok(ModuleGraphEdge {
                kind: edge_kind(&input.role)?.to_string(),
                from: format!("program:{program_id}"),
                to: input.id.clone(),
            })
        })
        .collect::<Result<Vec<_>, String>>()?;
    edges.sort();
    Ok(edges)
}

fn build_module_graph_program(
    root: &Path,
    program: &SemanticCorpusProgram,
) -> Result<ModuleGraphProgram, String> {
    let program_path = validate_corpus_relative_path(root, &program.path, "program.path")?;
    let (source_digest, records) = source_records(&program_path)?;
    let input_graph_digest = input_graph_digest(&records);
    let inputs = build_inputs(root, records)?;
    let mut output = ModuleGraphProgram {
        id: program.id.clone(),
        path: program.path.clone(),
        source_digest,
        input_graph_digest: module_digest(input_graph_digest.hex),
        module_graph_digest: module_digest(String::new()),
        inputs,
        edges: Vec::new(),
        known_gaps: program_known_gaps(),
    };
    output.edges = build_edges(&output.id, &output.inputs)?;
    output.module_graph_digest = program_digest(&output)?;
    Ok(output)
}

pub(crate) fn build_module_graph_receipt(
    root: &Path,
    manifest: &SemanticCorpusManifest,
) -> Result<ModuleGraphReceipt, String> {
    let programs = manifest
        .programs
        .iter()
        .map(|program| build_module_graph_program(root, program))
        .collect::<Result<Vec<_>, _>>()?;
    let summary = summarize_programs(&programs);
    Ok(ModuleGraphReceipt {
        schema: MODULE_GRAPH_SCHEMA.to_string(),
        receipt_id: "module-graph-semantic-corpus-2026-06-18".to_string(),
        created_at: "2026-06-18".to_string(),
        compiler: "buildc".to_string(),
        language: "buildlang".to_string(),
        source_set: ModuleGraphSourceSet {
            kind: "semantic-corpus".to_string(),
            manifest: "manifest.json".to_string(),
            program_count: manifest.programs.len(),
        },
        module_model: module_model(),
        programs,
        summary,
    })
}

fn summarize_programs(programs: &[ModuleGraphProgram]) -> ModuleGraphSummary {
    let mut input_roles = BTreeSet::new();
    let mut edge_kinds = BTreeSet::new();
    let mut input_count = 0;
    for program in programs {
        input_count += program.inputs.len();
        input_roles.extend(program.inputs.iter().map(|input| input.role.clone()));
        edge_kinds.extend(program.edges.iter().map(|edge| edge.kind.clone()));
    }
    ModuleGraphSummary {
        program_count: programs.len(),
        input_count,
        input_roles: sorted(input_roles),
        edge_kinds: sorted(edge_kinds),
        known_gaps: summary_known_gaps(),
    }
}