dol 0.8.1

DOL (Design Ontology Language) - A declarative specification language for ontology-first development
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

//! Compile Counter.dol to counter.wasm for vertical slice testing
//! Run with: cargo run --example compile_counter --features wasm

use metadol::parse_dol_file;
use metadol::wasm::WasmCompiler;
use std::fs;

fn main() {
    let source = r#"
/// Counter gene with increment and add methods
gene Counter {
    has value: Int64

    fun increment() -> Int64 {
        return value + 1
    }

    fun get_value() -> Int64 {
        return value
    }

    fun add(n: Int64) -> Int64 {
        return value + n
    }
}

/// Standalone function for simpler test
fun add_numbers(a: Int64, b: Int64) -> Int64 {
    return a + b
}
"#;

    println!("=== Compiling Counter.dol to WASM ===\n");

    // Parse
    println!("--- Parsing ---");
    let file = match parse_dol_file(source) {
        Ok(f) => f,
        Err(e) => {
            eprintln!("Parse error: {:?}", e);
            std::process::exit(1);
        }
    };
    println!("Parsed {} declarations", file.declarations.len());

    // Compile to WASM
    println!("\n--- Compiling to WASM ---");
    let mut compiler = WasmCompiler::new();
    let wasm_bytes = match compiler.compile_file(&file) {
        Ok(bytes) => bytes,
        Err(e) => {
            eprintln!("Compile error: {}", e.message);
            std::process::exit(1);
        }
    };
    println!("Generated {} bytes of WASM", wasm_bytes.len());

    // Write to file
    fs::create_dir_all("vertical-slice-results").unwrap();
    let output_path = "vertical-slice-results/counter.wasm";
    fs::write(output_path, &wasm_bytes).expect("Failed to write WASM file");
    println!("\nWrote: {}", output_path);

    // Validate with wasmtime
    println!("\n--- Validating WASM ---");
    let engine = wasmtime::Engine::default();
    match wasmtime::Module::new(&engine, &wasm_bytes) {
        Ok(wasm_module) => {
            println!("WASM validated successfully!");
            println!("\nExports:");
            for export in wasm_module.exports() {
                println!("  - {}", export.name());
            }
        }
        Err(e) => {
            eprintln!("Validation error: {}", e);
            std::process::exit(1);
        }
    }

    println!("\n=== Compilation Complete ===");
}