ruchy 4.1.1

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
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
102
103
104
105
106
107
108
109
110

//! JIT Compilation Module for Ruchy
//!
//! JIT-001: Proof of Concept - Cranelift-based Just-In-Time compilation
//!
//! # Performance Goals
//! - fibonacci(20): <0.5ms (vs 19ms AST interpreter - 38x speedup minimum)
//! - Compilation overhead: <10ms per function
//! - Expected speedup: 50-100x over AST interpreter
//!
//! # Architecture
//! ```
//! Ruchy AST → Cranelift IR → Native Machine Code → Execute
//! ```
//!
//! # Implementation Phases
//! - JIT-001 (Current): Proof of concept - arithmetic expressions
//! - JIT-002: Full language support (control flow, data structures)
//! - JIT-003: Tiered optimization with profiling
//!
//! # References
//! - GitHub Issue #135: <https://github.com/paiml/ruchy/issues/135>
//! - Cranelift Docs: <https://cranelift.dev/>
//! - `SimpleJIT` Example: <https://github.com/bytecodealliance/wasmtime/blob/main/cranelift/simplejit>

pub mod compiler;
pub mod lowering;

pub use compiler::JitCompiler;

use crate::frontend::ast::Expr;
use anyhow::Result;

/// JIT compile and execute a Ruchy expression
///
/// # Example
/// ```ignore
/// let ast = parse("2 + 2");
/// let result = jit_execute(&ast)?;
/// assert_eq!(result, 4);
/// ```
pub fn jit_execute(ast: &Expr) -> Result<i64> {
    let mut compiler = JitCompiler::new()?;
    compiler.compile_and_execute(ast)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::frontend::parser::Parser;

    #[test]
    #[ignore = "Enable once JIT implementation is complete"]
    fn test_jit_simple_arithmetic() {
        let code = "2 + 2";
        let ast = Parser::new(code)
            .parse()
            .expect("operation should succeed in test");
        let result = jit_execute(&ast).expect("operation should succeed in test");
        assert_eq!(result, 4);
    }

    #[test]
    #[ignore = "Enable once JIT implementation is complete"]
    fn test_jit_fibonacci_10() {
        let code = r"
            fun fib(n: i32) -> i32 {
                if n <= 1 {
                    n
                } else {
                    fib(n - 1) + fib(n - 2)
                }
            }
            fib(10)
        ";
        let ast = Parser::new(code)
            .parse()
            .expect("operation should succeed in test");
        let result = jit_execute(&ast).expect("operation should succeed in test");
        assert_eq!(result, 55); // fibonacci(10) = 55
    }

    // === EXTREME TDD Round 16 tests ===

    #[test]
    fn test_jit_compiler_creation() {
        // JitCompiler::new() should not panic
        let compiler_result = JitCompiler::new();
        assert!(compiler_result.is_ok(), "JitCompiler::new() should succeed");
    }

    #[test]
    fn test_jit_execute_parse_error_propagation() {
        // Test that invalid AST is handled gracefully
        let code = "42";
        let ast = Parser::new(code)
            .parse()
            .expect("operation should succeed in test");
        // jit_execute may fail for non-function expressions
        let _ = jit_execute(&ast); // Just verify it doesn't panic
    }

    #[test]
    fn test_jit_module_exports() {
        // Verify module structure exports are correct
        let _compiler: Result<JitCompiler> = JitCompiler::new();
        // Verify jit_execute is exported
        fn _check_export(_f: fn(&Expr) -> Result<i64>) {}
        _check_export(jit_execute);
    }
}