ruchy 4.2.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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use super::*;

#[test]
fn test_try_range_operators_less_than_comparison() {
    // MISSED: replace < with == in try_range_operators (line 686)

    let mut state = ParserState::new("..10");
    let left = Expr {
        kind: ExprKind::Literal(Literal::Integer(0, None)),
        span: Span { start: 0, end: 0 },
        attributes: Vec::new(),
        leading_comments: vec![],
        trailing_comment: None,
    };

    // Test when prec < min_prec (should return None)
    let result = try_range_operators(&mut state, left.clone(), &Token::DotDot, 10);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_none(),
        "Should return None when prec < min_prec (not ==)"
    );

    // Test when prec >= min_prec (should return Some)
    let mut state = ParserState::new("..10");
    let result = try_range_operators(&mut state, left, &Token::DotDot, 5);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_some(),
        "Should return Some when prec >= min_prec"
    );
}

#[test]
fn test_try_range_operators_plus_arithmetic() {
    // MISSED: replace + with * in try_range_operators (line 691)

    let mut state = ParserState::new("..10");
    let left = Expr {
        kind: ExprKind::Literal(Literal::Integer(0, None)),
        span: Span { start: 0, end: 0 },
        attributes: Vec::new(),
        leading_comments: vec![],
        trailing_comment: None,
    };

    let result = try_range_operators(&mut state, left, &Token::DotDot, 1);
    assert!(result.is_ok());

    // The RHS should parse with precedence prec+1 (not prec*1)
    // This ensures proper right-associativity
    if let Ok(Some(expr)) = result {
        assert!(
            matches!(expr.kind, ExprKind::Range { .. }),
            "Should parse range correctly with + operator"
        );
    }
}

#[test]
fn test_try_assignment_operators_less_than_comparison() {
    // MISSED: replace < with <= in try_assignment_operators (line 590)

    let mut state = ParserState::new("= 42");
    let left = Expr {
        kind: ExprKind::Identifier("x".to_string()),
        span: Span { start: 0, end: 0 },
        attributes: Vec::new(),
        leading_comments: vec![],
        trailing_comment: None,
    };

    // Test boundary: when prec == min_prec
    // With <: returns Some (prec is NOT < min_prec)
    // With <=: would return None (prec IS <= min_prec)
    let result = try_assignment_operators(&mut state, left.clone(), &Token::Equal, 1);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_some(),
        "Should return Some when prec == min_prec (using <, not <=)"
    );

    // Test when prec < min_prec (should return None)
    let mut state = ParserState::new("= 42");
    let result = try_assignment_operators(&mut state, left, &Token::Equal, 10);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_none(),
        "Should return None when prec < min_prec"
    );
}

#[test]
fn test_try_assignment_operators_equals_comparison() {
    // MISSED: replace < with == in try_assignment_operators (line 590)

    let mut state = ParserState::new("= 42");
    let left = Expr {
        kind: ExprKind::Identifier("x".to_string()),
        span: Span { start: 0, end: 0 },
        attributes: Vec::new(),
        leading_comments: vec![],
        trailing_comment: None,
    };

    // Test when prec < min_prec (should return None with < operator)
    let result = try_assignment_operators(&mut state, left.clone(), &Token::Equal, 10);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_none(),
        "Should return None when prec < min_prec (not ==)"
    );

    // Test when prec > min_prec (should return Some)
    let mut state = ParserState::new("= 42");
    let result = try_assignment_operators(&mut state, left, &Token::Equal, 0);
    assert!(result.is_ok());
    assert!(
        result.expect("result should be Some in test").is_some(),
        "Should return Some when prec > min_prec"
    );
}

#[test]
fn test_try_ternary_operator_plus_arithmetic() {
    // MISSED: replace + with * in try_ternary_operator (line 464)

    let mut state = ParserState::new("? 1 : 0");
    let left = Expr {
        kind: ExprKind::Literal(Literal::Bool(true)),
        span: Span { start: 0, end: 0 },
        attributes: Vec::new(),
        leading_comments: vec![],
        trailing_comment: None,
    };

    let result = try_ternary_operator(&mut state, left, &Token::Question, 1);
    assert!(result.is_ok());

    // The true branch should parse with TERNARY_PRECEDENCE+1 (not *1)
    // This tests the correct arithmetic operator
    if let Ok(Some(expr)) = result {
        assert!(
            matches!(expr.kind, ExprKind::Ternary { .. }),
            "Should parse ternary with + operator"
        );
    }
}