oxc_coverage_instrument 0.3.13

Istanbul-compatible JavaScript/TypeScript coverage instrumentation using the Oxc AST
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

#![expect(
    clippy::print_stderr,
    reason = "example binary — eprintln is the intended output mechanism"
)]
//! Profile each phase of the instrumentation pipeline.
//!
//! Run with: `cargo run --release --example profile`

use oxc_allocator::Allocator;
use oxc_codegen::Codegen;
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;
use oxc_span::SourceType;
use std::time::Instant;

fn main() {
    let source = std::fs::read_to_string(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/tests/fixtures/large-module.js"
    ))
    .unwrap();
    let iterations = 3000;

    eprintln!("File: large-module.js ({} bytes)", source.len());
    eprintln!("Iterations: {iterations}\n");

    // Phase 1: Parse only
    let start = Instant::now();
    for _ in 0..iterations {
        let allocator = Allocator::default();
        let source_type = SourceType::from_path("large-module.js").unwrap_or_default();
        let _ = Parser::new(&allocator, &source, source_type).parse();
    }
    let parse_time = start.elapsed();
    let parse_avg = parse_time.as_micros() as f64 / f64::from(iterations);

    // Phase 2: Parse + Semantic
    let start = Instant::now();
    for _ in 0..iterations {
        let allocator = Allocator::default();
        let source_type = SourceType::from_path("large-module.js").unwrap_or_default();
        let parsed = Parser::new(&allocator, &source, source_type).parse();
        let _ = SemanticBuilder::new().build(&parsed.program);
    }
    let semantic_time = start.elapsed();
    let semantic_avg = semantic_time.as_micros() as f64 / f64::from(iterations);

    // Phase 3: Parse + Semantic + Codegen (no transform)
    let start = Instant::now();
    for _ in 0..iterations {
        let allocator = Allocator::default();
        let source_type = SourceType::from_path("large-module.js").unwrap_or_default();
        let parsed = Parser::new(&allocator, &source, source_type).parse();
        let semantic_ret = SemanticBuilder::new().build(&parsed.program);
        let scoping = semantic_ret.semantic.into_scoping();
        let _ = Codegen::new()
            .with_source_text(&source)
            .with_scoping(Some(scoping))
            .build(&parsed.program);
    }
    let codegen_time = start.elapsed();
    let codegen_avg = codegen_time.as_micros() as f64 / f64::from(iterations);

    // Phase 4: Full instrument
    let start = Instant::now();
    for _ in 0..iterations {
        let opts = oxc_coverage_instrument::InstrumentOptions::default();
        let _ = oxc_coverage_instrument::instrument(&source, "large-module.js", &opts);
    }
    let full_time = start.elapsed();
    let full_avg = full_time.as_micros() as f64 / f64::from(iterations);

    eprintln!("Phase breakdown:");
    eprintln!("  Parse:         {parse_avg:>8.1}µs ({:.0}%)", parse_avg / full_avg * 100.0);
    eprintln!(
        "  + Semantic:    {:>8.1}µs ({:.0}% incremental)",
        semantic_avg,
        (semantic_avg - parse_avg) / full_avg * 100.0
    );
    eprintln!(
        "  + Codegen:     {:>8.1}µs ({:.0}% incremental)",
        codegen_avg,
        (codegen_avg - semantic_avg) / full_avg * 100.0
    );
    eprintln!("  Full pipeline: {full_avg:>8.1}µs");
    eprintln!(
        "  Transform:     {:>8.1}µs ({:.0}% — our code + preamble)",
        full_avg - codegen_avg,
        (full_avg - codegen_avg) / full_avg * 100.0
    );
    eprintln!(
        "\nThroughput: {:.1} MiB/s",
        (source.len() as f64 / 1024.0 / 1024.0) / (full_avg / 1_000_000.0)
    );
}