ruchy 4.2.0

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#![cfg(test)]
#![allow(warnings)]
#![allow(clippy::assertions_on_constants)]
#![allow(clippy::unreadable_literal)]
//! Tests for reference operator (&) functionality

#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::print_stdout)]
#![allow(clippy::uninlined_format_args)]
#![allow(clippy::single_char_pattern)]

use ruchy::runtime::Repl;
use std::env;

#[test]
fn test_reference_operator_parsing() {
    let mut repl = Repl::new(std::env::temp_dir()).expect("Failed to create REPL");

    // Check that reference operator can be parsed
    let result = repl.eval("&42");
    if let Err(e) = &result {
        println!("Error parsing &42: {}", e);
    }
    assert!(
        result.is_ok(),
        "Reference operator should parse successfully: {:?}",
        result
    );

    // Check reference with variable
    repl.eval("let x = 10").unwrap();
    let result = repl.eval("&x");
    if let Err(e) = &result {
        println!("Error parsing &x: {}", e);
    }
    assert!(
        result.is_ok(),
        "Reference to variable should work: {:?}",
        result
    );
}

#[test]
fn test_reference_operator_with_expressions() {
    let mut repl = Repl::new(std::env::temp_dir()).expect("Failed to create REPL");

    // Check reference with more complex expressions
    let result = repl.eval("&(1 + 2)");
    assert!(result.is_ok(), "Reference to expression should work");

    // Check reference with parenthesized expression
    let result = repl.eval("&(100)");
    assert!(
        result.is_ok(),
        "Reference to parenthesized value should work"
    );
}

#[test]
fn test_reference_operator_priority() {
    let mut repl = Repl::new(std::env::temp_dir()).expect("Failed to create REPL");

    // Check that reference operator has correct precedence as unary operator
    let result = repl.eval("&!true");
    assert!(
        result.is_ok(),
        "Reference should work with other unary operators"
    );

    let result = repl.eval("&-42");
    assert!(result.is_ok(), "Reference should work with negation");
}

#[test]
fn test_reference_vs_bitwise_and() {
    let mut repl = Repl::new(std::env::temp_dir()).expect("Failed to create REPL");

    // Check that & still works as bitwise AND in binary context
    let result = repl.eval("5 & 3");
    if let Err(e) = &result {
        println!("Error evaluating 5 & 3: {}", e);
    }
    assert!(
        result.is_ok(),
        "Bitwise AND should still work: {:?}",
        result
    );

    // Check that context determines interpretation
    let result = repl.eval("&5 & 3");
    assert!(result.is_ok(), "Reference and bitwise AND should coexist");
}

#[test]
fn test_reference_operator_transpilation() {
    use ruchy::backend::transpiler::Transpiler;
    use ruchy::frontend::ast::{Expr, ExprKind, Literal, Span, UnaryOp};

    let mut transpiler = Transpiler::new();

    // Create a reference expression manually
    let operand = Box::new(Expr::new(
        ExprKind::Literal(Literal::Integer(42)),
        Span::new(0, 2),
    ));

    let ref_expr = Expr::new(
        ExprKind::Unary {
            op: UnaryOp::Reference,
            operand,
        },
        Span::new(0, 3),
    );

    // Check transpilation
    let result = transpiler.transpile(&ref_expr);
    assert!(result.is_ok(), "Reference expression should transpile");

    let rust_code = result.unwrap().to_string();
    assert!(
        rust_code.contains("&"),
        "Transpiled code should contain reference operator"
    );
    assert!(
        rust_code.contains("42"),
        "Transpiled code should contain the operand"
    );
}