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

#![allow(missing_docs)]
//! Tests for PARSER-062: Comments after control flow statements
//!
//! Bug: Inline comments after break/continue/return cause parser failures
//! Root cause: Comment tokens not skipped when checking for terminators
//!
//! Example failure:
//! ```ruchy
//! for n in [1, 2, 3] {
//!     if n > 1 {
//!         break  // Comment here
//!     }
//! }
//! ```
//! Error: "Expected body after for iterator: Expected `RightBrace`, found If"

use ruchy::Parser;

#[test]
fn test_parser_062_break_with_inline_comment() {
    let input = r"
for n in [1, 2, 3] {
    if n > 1 {
        break  // Exit loop
    }
}
";
    let mut parser = Parser::new(input);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Parser should handle inline comments after break: {:?}",
        result.err()
    );
}

#[test]
fn test_parser_062_continue_with_inline_comment() {
    let input = r"
for n in [1, 2, 3] {
    if n == 2 {
        continue  // Skip this iteration
    }
    print(n)
}
";
    let mut parser = Parser::new(input);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Parser should handle inline comments after continue: {:?}",
        result.err()
    );
}

#[test]
fn test_parser_062_return_with_inline_comment() {
    let input = r#"
fun test() {
    if true {
        return  // Early exit
    }
    print("unreachable")
}
"#;
    let mut parser = Parser::new(input);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Parser should handle inline comments after return: {:?}",
        result.err()
    );
}

#[test]
fn test_parser_062_full_book_example() {
    let input = r"
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let has_large = false

for n in numbers {
  if n > 100 {
    has_large = true
    break  // Exit early, no need to check rest
  }
}

has_large  // Returns: false
";
    let mut parser = Parser::new(input);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Parser should handle full book example with comments: {:?}",
        result.err()
    );
}

#[test]
fn test_parser_062_multiple_comments_in_nested_blocks() {
    let input = r"
for i in 0..10 {
    for j in 0..10 {
        if i == j {
            continue  // Skip diagonal
        }
        if i + j > 15 {
            break  // Exit inner loop
        }
        print(i, j)
    }
}
";
    let mut parser = Parser::new(input);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Parser should handle multiple comments in nested blocks: {:?}",
        result.err()
    );
}