tsv_ts 0.8.0

TypeScript/JS formatter, type stripper and acorn-compatible parser — part of tsv
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

//! Opt-in printer buffer-population sampling — the data source behind
//! `tsv_debug buffer_sizes`' chain/comment metrics.
//!
//! The printer's `SmallVec` inline capacities (`ChainNodeVec`, `ChainGroupVec`,
//! the leading-comment `CommentVec`) are sizing claims, and a claim in a doc
//! comment drifts; this module samples the real populations at the buffers'
//! construction chokepoints so the inline-`N` choice is graded against measured
//! lengths on any corpus.
//!
//! Compiled in only under the `_internal_buffer_stats` cargo feature (off by default,
//! like `_internal_debug_lex`), so production builds — and default `tsv_debug` builds,
//! whose profiles must measure production-shaped code — carry no recording. A
//! feature-enabled binary still records nothing until armed via
//! [`set_buffer_stats`] (the `buffer_sizes` command arms it), so other commands
//! in the same binary stay unperturbed. Recording is output-neutral either way.

use std::cell::RefCell;
use std::sync::atomic::{AtomicBool, Ordering};

use super::chain::{ChainGroupVec, ChainNodeVec};
use super::comments::CommentVec;

static ENABLED: AtomicBool = AtomicBool::new(false);

/// Arm or disarm recording process-wide. Recording is per-thread (the sink is a
/// thread-local); the driving command formats on one thread and drains there.
pub fn set_buffer_stats(enabled: bool) {
    ENABLED.store(enabled, Ordering::Relaxed);
}

#[inline]
fn enabled() -> bool {
    ENABLED.load(Ordering::Relaxed)
}

/// One sampled population per instrumented buffer. Lengths are recorded at the
/// point the buffer's final size is known, one sample per construction.
#[derive(Debug, Default, Clone)]
pub struct BufferStats {
    /// `ChainNodeVec` length per linearized chain (`finalize_chain_nodes`).
    pub chain_nodes: Vec<usize>,
    /// `ChainGroupVec` length per `group_chain_nodes` call.
    pub chain_groups: Vec<usize>,
    /// Leading-comment `CommentVec` length per `collect_leading_comments` call
    /// (the statement-gap collector — the buffer type's dominant allocation
    /// site; other `CommentVec` sites are not sampled).
    pub leading_comments: Vec<usize>,
}

/// The instrumented buffer types' *current* inline capacities, read from the
/// types themselves so the `buffer_sizes` report labels can't drift when an
/// `N` is re-tuned. Fields mirror [`BufferStats`].
#[derive(Debug, Clone, Copy)]
pub struct BufferInlineCapacities {
    /// `ChainNodeVec`'s inline capacity.
    pub chain_nodes: usize,
    /// `ChainGroupVec`'s inline capacity.
    pub chain_groups: usize,
    /// `CommentVec`'s inline capacity.
    pub leading_comments: usize,
}

/// See [`BufferInlineCapacities`].
pub fn inline_capacities() -> BufferInlineCapacities {
    BufferInlineCapacities {
        chain_nodes: ChainNodeVec::new().inline_size(),
        chain_groups: ChainGroupVec::new().inline_size(),
        leading_comments: CommentVec::new().inline_size(),
    }
}

thread_local! {
    static SINK: RefCell<BufferStats> = RefCell::new(BufferStats::default());
}

pub(crate) fn record_chain_nodes(len: usize) {
    if enabled() {
        SINK.with(|s| s.borrow_mut().chain_nodes.push(len));
    }
}

pub(crate) fn record_chain_groups(len: usize) {
    if enabled() {
        SINK.with(|s| s.borrow_mut().chain_groups.push(len));
    }
}

pub(crate) fn record_leading_comments(len: usize) {
    if enabled() {
        SINK.with(|s| s.borrow_mut().leading_comments.push(len));
    }
}

/// Drain this thread's recorded samples.
pub fn take_buffer_stats() -> BufferStats {
    SINK.with(|s| std::mem::take(&mut *s.borrow_mut()))
}