tinymist 0.14.18-rc1

An integrated language service for Typst.
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

//! Statistics about the analyzers

use std::path::{Path, PathBuf};
use std::sync::{Arc, OnceLock};
use tinymist_std::time::Duration;

use parking_lot::Mutex;
use reflexo::{hash::FxDashMap, path::unix_slash};

#[derive(Clone)]
pub(crate) struct QueryStatBucketData {
    pub query: u64,
    pub total: Duration,
    pub snap: Duration,
    pub min: Duration,
    pub max: Duration,
}

impl Default for QueryStatBucketData {
    fn default() -> Self {
        Self {
            query: 0,
            total: Duration::from_secs(0),
            snap: Duration::from_secs(0),
            min: Duration::from_secs(u64::MAX),
            max: Duration::from_secs(0),
        }
    }
}

/// Statistics about some query
#[derive(Default, Clone)]
pub struct QueryStatBucket {
    pub(crate) data: Arc<Mutex<QueryStatBucketData>>,
}

pub struct QueryStatGuard {
    pub bucket: QueryStatBucket,
    pub since: tinymist_std::time::Instant,
    pub snap_since: OnceLock<tinymist_std::time::Duration>,
}

impl Drop for QueryStatGuard {
    fn drop(&mut self) {
        let elapsed = self.since.elapsed();
        let mut data = self.bucket.data.lock();
        data.query += 1;
        data.total += elapsed;
        data.snap += self.snap_since.get().cloned().unwrap_or_default();
        data.min = data.min.min(elapsed);
        data.max = data.max.max(elapsed);
    }
}

impl QueryStatGuard {
    pub(crate) fn snap(&self) {
        self.snap_since.get_or_init(|| self.since.elapsed());
    }
}

/// Statistics about the analyzers
#[derive(Default)]
pub struct CompilerQueryStats {
    pub(crate) query_stats: FxDashMap<PathBuf, FxDashMap<&'static str, QueryStatBucket>>,
}

impl CompilerQueryStats {
    /// Record a query.
    pub(crate) fn query_stat(&self, path: Option<&Path>, name: &'static str) -> QueryStatGuard {
        let stats = &self.query_stats;
        // let refs = stats.entry(path.clone()).or_default();
        let refs = stats
            .entry(path.unwrap_or_else(|| Path::new("")).to_path_buf())
            .or_default();
        let refs2 = refs.entry(name).or_default();
        QueryStatGuard {
            bucket: refs2.clone(),
            since: tinymist_std::time::Instant::now(),
            snap_since: OnceLock::new(),
        }
    }

    /// Report the statistics of the analysis.
    pub fn report(&self) -> String {
        let stats = &self.query_stats;
        let mut data = Vec::new();
        for refs in stats.iter() {
            let id = unix_slash(refs.key());
            let queries = refs.value();
            for refs2 in queries.iter() {
                let query = refs2.key();
                let bucket = refs2.value().data.lock().clone();
                let name = format!("{id:?}:{query}").replace('\\', "/");
                data.push((name, bucket));
            }
        }

        // sort by query duration
        data.sort_by(|x, y| y.1.max.cmp(&x.1.max));

        // format to html

        let mut html = String::new();
        html.push_str(r#"<div>
<style>
table.query-stats { width: 100%; border-collapse: collapse; }
table.query-stats th, table.query-stats td { border: 1px solid black; padding: 8px; text-align: center; }
table.query-stats th.name-column, table.query-stats td.name-column { text-align: left; }
table.query-stats tr:nth-child(odd) { background-color: rgba(242, 242, 242, 0.8); }
@media (prefers-color-scheme: dark) {
    table.query-stats tr:nth-child(odd) { background-color: rgba(50, 50, 50, 0.8); }
}
</style>
<table class="query-stats"><tr><th class="query-column">Query</th><th>Count</th><th>Total</th><th>Snap</th><th>Min</th><th>Max</th></tr>"#);

        for (name, bucket) in data {
            html.push_str("<tr>");
            html.push_str(&format!(r#"<td class="query-column">{name}</td>"#));
            html.push_str(&format!("<td>{}</td>", bucket.query));
            html.push_str(&format!("<td>{:?}</td>", bucket.total));
            html.push_str(&format!("<td>{:?}</td>", bucket.snap));
            html.push_str(&format!("<td>{:?}</td>", bucket.min));
            html.push_str(&format!("<td>{:?}</td>", bucket.max));
            html.push_str("</tr>");
        }
        html.push_str("</table>");
        html.push_str("</div>");

        html
    }
}