etdl-compiler 0.1.0

ETDL semantic validator, fault tree resolver, and code generator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

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

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

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

pub struct Compiler {
    pub rust_codegen: RustCodeGenerator,
}

#[derive(Debug, Clone)]
pub struct CompilationResult {
    pub diagnostics: Vec<Diagnostic>,
    pub rust_output: Option<String>,
}

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> {
        let mut diagnostics = Vec::new();

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

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

        let fault_tree_probs = fault_tree::resolve_fault_trees(doc, &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 {
        let mut diagnostics = self.validate(doc, asyncapi_registry);

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

        let fault_tree_probs = fault_tree::resolve_fault_trees(doc, &mut Vec::new());

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

        if gen_result.is_ok() {
            rust_output = gen_result.unwrap();
        }

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

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