leekscript-rs 0.1.0

LeekScript parser, formatter, and semantic analysis in Rust
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

//! Criterion benchmarks for parse(), analyze(), and format().

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use leekscript_rs::formatter::FormatterOptions;
use leekscript_rs::{analyze, format, parse};

const SMALL: &str = r#"
var x = 1;
return x + 2;
"#;

const MEDIUM: &str = r#"
function add(integer a, integer b) -> integer {
    return a + b;
}
function mul(integer a, integer b) -> integer {
    return a * b;
}
integer x = add(1, 2);
integer y = mul(x, 3);
return add(x, y);
"#;

const LARGE: &str = r#"
class Cell {
    public integer id;
    public integer x;
    public integer y;
    public boolean isWall;
    private constructor(integer id) {
        this.id = id;
    }
    public static Cell create(integer pos) {
        var cell = Cell.getCell(pos);
        if (cell == null) {
            push(Cell.cells, new Cell(pos));
        }
        return cell;
    }
    static Array<Cell> cells;
    static Cell? getCell(integer id) {
        return Cell.cells[id];
    }
}
class Entity {
    public integer id;
    public Cell cell;
    private constructor(integer id) {
        this.id = id;
    }
    public update() {
        this.cell = Cell.getCell(getCell(this.id));
    }
    public static Entity create(integer id) {
        return new Entity(id);
    }
    static Array<Entity> entities;
    static Entity? getEntity(integer id) {
        return Entity.entities[id];
    }
}
return null;
"#;

fn bench_parse(c: &mut Criterion) {
    let mut g = c.benchmark_group("parse");
    g.bench_function("parse_small", |b| {
        b.iter(|| parse(black_box(SMALL)).unwrap())
    });
    g.bench_function("parse_medium", |b| {
        b.iter(|| parse(black_box(MEDIUM)).unwrap())
    });
    g.bench_function("parse_large", |b| {
        b.iter(|| parse(black_box(LARGE)).unwrap())
    });
    g.finish();
}

fn bench_analyze(c: &mut Criterion) {
    let small_root = parse(SMALL).unwrap().expect("small");
    let medium_root = parse(MEDIUM).unwrap().expect("medium");
    let large_root = parse(LARGE).unwrap().expect("large");

    let mut g = c.benchmark_group("analyze");
    g.bench_function("analyze_small", |b| {
        b.iter(|| analyze(black_box(&small_root)))
    });
    g.bench_function("analyze_medium", |b| {
        b.iter(|| analyze(black_box(&medium_root)))
    });
    g.bench_function("analyze_large", |b| {
        b.iter(|| analyze(black_box(&large_root)))
    });
    g.finish();
}

fn bench_format(c: &mut Criterion) {
    let small_root = parse(SMALL).unwrap().expect("small");
    let medium_root = parse(MEDIUM).unwrap().expect("medium");
    let opts = FormatterOptions::default();

    let mut g = c.benchmark_group("format");
    g.bench_function("format_small", |b| {
        b.iter(|| format(black_box(&small_root), black_box(&opts)))
    });
    g.bench_function("format_medium", |b| {
        b.iter(|| format(black_box(&medium_root), black_box(&opts)))
    });
    g.finish();
}

criterion_group!(benches, bench_parse, bench_analyze, bench_format);
criterion_main!(benches);