etdl_compiler/

lib.rs

//! Compiler pipeline for the Event Tree Definition Language (ETDL).
//!
//! Validates `.etdl` documents, resolves fault tree top-event probabilities
//! ([IEC 61025:2006](https://github.com/usamassem/etdl-specification)), and
//! generates service-local code. Reliability — event trees (IEC 62502),
//! fault trees (IEC 61025), retry policies, SLAs — becomes a build-time,
//! machine-checked artifact instead of scattered runtime guesses.
//!
//! # Pipeline
//!
//! 1. [`validate::validate_document`] — structural and semantic diagnostics (E-1xx,
//!    V-1xx..V-5xx, W-4xx)
//! 2. [`fault_tree::resolve_fault_trees`] — exact top-event probability evaluation
//!    (AND/OR/NOT/XOR/VOTING gates, exponential failure model)
//! 3. [`typeck`] — ECEL condition type-checking against AsyncAPI schemas
//! 4. [`codegen::CodeGenerator`] — backend trait; [`codegen::RustCodeGenerator`]
//!    emits async handlers with embedded probabilities, retry policies, and
//!    `etdl-core` instrumentation
//!
//! # Example
//!
//! ```no_run
//! use etdl_compiler::Compiler;
//! use etdl_parser::{parse_document_from_file, load_asyncapi_imports};
//! use std::path::Path;
//!
//! let base = Path::new(".");
//! let doc = parse_document_from_file(&base.join("order-fulfillment.etdl"))?;
//! let registry = load_asyncapi_imports(&doc, base)?;
//! let result = Compiler::new().compile(&doc, &registry);
//! assert!(result.diagnostics.iter().all(|d| !d.is_error()));
//! assert!(result.rust_output.is_some());
//! # Ok::<(), String>(())
//! ```

use etdl_parser::ast::EtlDocument;
use etdl_parser::asyncapi::AsyncApiRegistry;

pub mod codegen;
pub mod fault_tree;
pub mod reliability;
mod typeck;
pub mod validate;

pub use codegen::{CodeGenerator, RustCodeGenerator};
pub use validate::Diagnostic;

pub struct Compiler {
    pub rust_codegen: RustCodeGenerator,
}

/// A complete compilation result including optional reliability provenance.
#[derive(Debug, Clone)]
pub struct CompilationResult {
    pub diagnostics: Vec<Diagnostic>,
    pub rust_output: Option<String>,
    /// Reliability build manifest, present when the document declares the
    /// reliability supplement and external sources were resolved.
    pub build_manifest: Option<serde_json::Value>,
}

impl Compiler {
    pub fn new() -> Self {
        Compiler {
            rust_codegen: RustCodeGenerator::new(),
        }
    }

    /// Run the full validation pipeline (semantic checks, fault-tree
    /// resolution, probability validation, ECEL type checking) without
    /// generating any code.
    pub fn validate(
        &self,
        doc: &EtlDocument,
        asyncapi_registry: &AsyncApiRegistry,
    ) -> Vec<Diagnostic> {
        self.validate_with_base(doc, asyncapi_registry, std::path::Path::new("."))
    }

    /// Validate, resolving external reliability sources relative to `base_dir`.
    pub fn validate_with_base(
        &self,
        doc: &EtlDocument,
        asyncapi_registry: &AsyncApiRegistry,
        base_dir: &std::path::Path,
    ) -> Vec<Diagnostic> {
        let mut diagnostics = Vec::new();

        validate::validate_document(doc, asyncapi_registry, &mut diagnostics);

        if diagnostics.iter().any(|d| d.is_error()) {
            return diagnostics;
        }

        // Resolve external reliability sources so that basic events whose
        // probability comes from an artifact can be evaluated.
        let (resolved_events, _manifest) =
            reliability::resolve_reliability(doc, base_dir, &mut diagnostics);
        let overrides: fault_tree::BasicEventOverrides = resolved_events
            .iter()
            .map(|r| (r.basic_event.clone(), r.resolved.value))
            .collect();

        let fault_tree_probs =
            fault_tree::resolve_fault_trees_with_overrides(doc, &overrides, &mut diagnostics);
        let resolved_probabilities =
            validate::resolve_probability_links(doc, &fault_tree_probs, &mut diagnostics);

        validate::validate_probability_sums(doc, &resolved_probabilities, &mut diagnostics);

        if diagnostics.iter().any(|d| d.is_error()) {
            return diagnostics;
        }

        typeck::type_check_conditions(doc, asyncapi_registry, &mut diagnostics);

        diagnostics
    }

    pub fn compile(
        &self,
        doc: &EtlDocument,
        asyncapi_registry: &AsyncApiRegistry,
    ) -> CompilationResult {
        self.compile_with_base(doc, asyncapi_registry, std::path::Path::new("."))
    }

    /// Compile with a base directory for resolving relative reliability
    /// artifact paths.
    pub fn compile_with_base(
        &self,
        doc: &EtlDocument,
        asyncapi_registry: &AsyncApiRegistry,
        base_dir: &std::path::Path,
    ) -> CompilationResult {
        let mut diagnostics = self.validate_with_base(doc, asyncapi_registry, base_dir);

        let has_errors = diagnostics.iter().any(|d| d.is_error());
        if has_errors {
            return CompilationResult {
                diagnostics,
                rust_output: None,
                build_manifest: None,
            };
        }

        // Reliability: resolve external probability sources to deterministic
        // scalars BEFORE fault-tree evaluation. Preserves the build-time
        // resolution model; nothing is resolved at runtime.
        let (resolved_events, manifest) =
            reliability::resolve_reliability(doc, base_dir, &mut diagnostics);

        let overrides: fault_tree::BasicEventOverrides = resolved_events
            .iter()
            .map(|r| (r.basic_event.clone(), r.resolved.value))
            .collect();

        let build_manifest = manifest.as_ref().and_then(|m| serde_json::to_value(m).ok());

        let fault_tree_probs =
            fault_tree::resolve_fault_trees_with_overrides(doc, &overrides, &mut diagnostics);

        let mut rust_output = String::new();
        let gen_result = self.rust_codegen.generate_all(
            doc,
            &fault_tree_probs,
            asyncapi_registry,
            &mut diagnostics,
        );

        if let Ok(gen_code) = gen_result {
            rust_output = gen_code;
        }

        CompilationResult {
            diagnostics,
            rust_output: if rust_output.is_empty() {
                None
            } else {
                Some(rust_output)
            },
            build_manifest,
        }
    }
}

impl Default for Compiler {
    fn default() -> Self {
        Self::new()
    }
}