bashrs 6.66.1

Rust-to-Shell transpiler for deterministic bootstrap scripts
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)] // Benchmarks can use unwrap() for simplicity
                               // Bash Purification Performance Benchmarks (Task 1 of 10: 70% → 100% Production)
                               // Target: <100ms per 1000 lines (scalability verification for production workloads)
                               //
                               // Fixtures:
                               // - small.sh: ~50 lines (basic purification opportunities)
                               // - medium.sh: ~500 lines (moderate complexity with functions)
                               // - large.sh: ~5741 lines (real-world production-scale script)
                               //
                               // Performance Baselines:
                               // - Small (<50 lines): Target <5ms (interactive CLI experience)
                               // - Medium (~500 lines): Target <50ms (responsive for CI/CD)
                               // - Large (~5000 lines): Target <500ms (<100ms/1000 lines)

use bashrs::bash_parser::BashParser;
use bashrs::bash_transpiler::purification::{PurificationOptions, Purifier};
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use std::hint::black_box;

// Benchmark fixtures
// Issue #4 RESOLVED: Parser now supports $RANDOM, $$, $(cmd), function keyword
const SMALL_BASH: &str = include_str!("fixtures/small.sh");
const MEDIUM_BASH: &str = include_str!("fixtures/medium.sh");
const LARGE_BASH: &str = include_str!("fixtures/large.sh");

/// Benchmark parsing only (bash → AST)
fn benchmark_parse(c: &mut Criterion) {
    let mut group = c.benchmark_group("bash_parse");

    group.bench_with_input(
        BenchmarkId::new("small", "50 lines"),
        &SMALL_BASH,
        |b, bash| {
            b.iter(|| {
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                parser.parse()
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "500 lines"),
        &MEDIUM_BASH,
        |b, bash| {
            b.iter(|| {
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                parser.parse()
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("large", "5741 lines"),
        &LARGE_BASH,
        |b, bash| {
            b.iter(|| {
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                parser.parse()
            })
        },
    );

    group.finish();
}

/// Benchmark purification only (AST → purified AST, no parsing)
fn benchmark_purify(c: &mut Criterion) {
    let mut group = c.benchmark_group("bash_purify");

    // Pre-parse the bash scripts to isolate purification performance
    let small_ast = {
        let mut parser = BashParser::new(SMALL_BASH).expect("Failed to create parser");
        parser.parse().expect("Failed to parse small.sh")
    };

    let medium_ast = {
        let mut parser = BashParser::new(MEDIUM_BASH).expect("Failed to create parser");
        parser.parse().expect("Failed to parse medium.sh")
    };

    let large_ast = {
        let mut parser = BashParser::new(LARGE_BASH).expect("Failed to create parser");
        parser.parse().expect("Failed to parse large.sh")
    };

    group.bench_with_input(
        BenchmarkId::new("small", "50 lines"),
        &small_ast,
        |b, ast| {
            b.iter(|| {
                let mut purifier = Purifier::new(PurificationOptions::default());
                purifier.purify(black_box(ast))
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "500 lines"),
        &medium_ast,
        |b, ast| {
            b.iter(|| {
                let mut purifier = Purifier::new(PurificationOptions::default());
                purifier.purify(black_box(ast))
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("large", "5741 lines"),
        &large_ast,
        |b, ast| {
            b.iter(|| {
                let mut purifier = Purifier::new(PurificationOptions::default());
                purifier.purify(black_box(ast))
            })
        },
    );

    group.finish();
}

/// Benchmark end-to-end purification (parse + purify + codegen)
fn benchmark_end_to_end(c: &mut Criterion) {
    let mut group = c.benchmark_group("bash_purify_end_to_end");

    // Performance targets based on production requirements:
    // - Small (<50 lines): <5ms (interactive CLI)
    // - Medium (~500 lines): <50ms (CI/CD pipeline)
    // - Large (~5000 lines): <500ms (<100ms per 1000 lines)

    group.bench_with_input(
        BenchmarkId::new("small", "50 lines"),
        &SMALL_BASH,
        |b, bash| {
            b.iter(|| {
                // Parse
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                let ast = parser.parse().expect("Parse failed");

                // Purify
                let mut purifier = Purifier::new(PurificationOptions::default());
                let purified_ast = purifier.purify(&ast).expect("Purify failed");

                // Return purified AST (codegen measured separately if needed)
                black_box(purified_ast)
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "500 lines"),
        &MEDIUM_BASH,
        |b, bash| {
            b.iter(|| {
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                let ast = parser.parse().expect("Parse failed");

                let mut purifier = Purifier::new(PurificationOptions::default());
                let purified_ast = purifier.purify(&ast).expect("Purify failed");

                black_box(purified_ast)
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("large", "5741 lines"),
        &LARGE_BASH,
        |b, bash| {
            b.iter(|| {
                let mut parser = BashParser::new(black_box(bash)).expect("Failed to create parser");
                let ast = parser.parse().expect("Parse failed");

                let mut purifier = Purifier::new(PurificationOptions::default());
                let purified_ast = purifier.purify(&ast).expect("Purify failed");

                black_box(purified_ast)
            })
        },
    );

    group.finish();
}

/// Benchmark throughput (lines per second)
fn benchmark_throughput(c: &mut Criterion) {
    let mut group = c.benchmark_group("bash_purify_throughput");

    // Calculate lines per second for each fixture
    let small_lines = SMALL_BASH.lines().count();
    let medium_lines = MEDIUM_BASH.lines().count();
    let large_lines = LARGE_BASH.lines().count();

    group.bench_function(format!("small_{}_lines", small_lines).as_str(), |b| {
        b.iter(|| {
            let mut parser =
                BashParser::new(black_box(SMALL_BASH)).expect("Failed to create parser");
            let ast = parser.parse().expect("Parse failed");
            let mut purifier = Purifier::new(PurificationOptions::default());
            let purified = purifier.purify(&ast).expect("Purify failed");
            black_box(purified)
        })
    });

    group.bench_function(format!("medium_{}_lines", medium_lines).as_str(), |b| {
        b.iter(|| {
            let mut parser =
                BashParser::new(black_box(MEDIUM_BASH)).expect("Failed to create parser");
            let ast = parser.parse().expect("Parse failed");
            let mut purifier = Purifier::new(PurificationOptions::default());
            let purified = purifier.purify(&ast).expect("Purify failed");
            black_box(purified)
        })
    });

    group.bench_function(format!("large_{}_lines", large_lines).as_str(), |b| {
        b.iter(|| {
            let mut parser =
                BashParser::new(black_box(LARGE_BASH)).expect("Failed to create parser");
            let ast = parser.parse().expect("Parse failed");
            let mut purifier = Purifier::new(PurificationOptions::default());
            let purified = purifier.purify(&ast).expect("Purify failed");
            black_box(purified)
        })
    });

    group.finish();
}

criterion_group!(
    benches,
    benchmark_parse,
    benchmark_purify,
    benchmark_end_to_end,
    benchmark_throughput
);
criterion_main!(benches);