depyler-core 3.2.0

Core transpilation engine for the Depyler Python-to-Rust transpiler
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
149
150
151
152
153

//! Tests for range() with step parameter support

use depyler_core::DepylerPipeline;

#[test]
fn test_range_single_argument() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def count_to_five():
    for i in range(5):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(5):\n{}", rust_code);

    assert!(
        rust_code.contains("0..5"),
        "Should generate 0..5 for range(5)"
    );
}

#[test]
fn test_range_two_arguments() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def count_from_two():
    for i in range(2, 8):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(2, 8):\n{}", rust_code);

    assert!(
        rust_code.contains("2..8"),
        "Should generate 2..8 for range(2, 8)"
    );
}

#[test]
fn test_range_positive_step() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def count_by_twos():
    for i in range(0, 10, 2):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(0, 10, 2):\n{}", rust_code);

    assert!(
        rust_code.contains("step_by"),
        "Should use step_by for step parameter"
    );
    assert!(rust_code.contains("2"), "Should include step value 2");
}

#[test]
fn test_range_negative_step() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def count_down():
    for i in range(10, 0, -1):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(10, 0, -1):\n{}", rust_code);

    // Should handle negative step with rev()
    assert!(
        rust_code.contains("rev") || rust_code.contains("step_by"),
        "Should handle negative step"
    );
}

#[test]
fn test_range_large_step() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def count_by_fives():
    result = []
    for i in range(0, 25, 5):
        result.append(i)
    return result
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(0, 25, 5):\n{}", rust_code);

    assert!(rust_code.contains("step_by"), "Should use step_by");
    assert!(rust_code.contains("5"), "Should include step value 5");
}

#[test]
fn test_range_negative_bounds() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def negative_range():
    for i in range(-5, 5):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range(-5, 5):\n{}", rust_code);

    assert!(
        rust_code.contains("- 5..5") || rust_code.contains("-5..5"),
        "Should handle negative start"
    );
}

#[test]
fn test_range_with_variables() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def dynamic_range(start: int, end: int, step: int):
    result = []
    for i in range(start, end, step):
        result.append(i)
    return result
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range with variables:\n{}", rust_code);

    assert!(
        rust_code.contains("step_by"),
        "Should use step_by with variables"
    );
}

#[test]
fn test_range_zero_step_error() {
    let pipeline = DepylerPipeline::new();
    let python_code = r#"
def invalid_range():
    # This should generate code that panics at runtime like Python
    for i in range(0, 10, 0):
        print(i)
"#;

    let rust_code = pipeline.transpile(python_code).unwrap();
    println!("Generated code for range with zero step:\n{}", rust_code);

    // The generated code should handle zero step (might panic at runtime)
    assert!(
        rust_code.contains("range") || rust_code.contains("step"),
        "Should generate range code even with zero step"
    );
}