typespec_rs 0.1.0

A Rust implementation of the TypeSpec type system — parser, checker, and emitter
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
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

//! Compiler statistics
//!
//! Ported from TypeSpec compiler/src/core/stats.ts
//!
//! Provides data structures for tracking compilation complexity and runtime metrics.

use std::collections::HashMap;

/// Overall compiler statistics
#[derive(Debug, Clone, Default)]
pub struct Stats {
    /// Type complexity statistics
    pub complexity: ComplexityStats,
    /// Runtime performance statistics
    pub runtime: RuntimeStats,
}

/// Type complexity statistics
#[derive(Debug, Clone, Default)]
pub struct ComplexityStats {
    /// Number of types created
    pub created_types: usize,
    /// Number of types that have been finished (fully resolved)
    pub finished_types: usize,
}

/// Runtime performance statistics
#[derive(Debug, Clone, Default)]
pub struct RuntimeStats {
    /// Total compilation time in microseconds
    pub total: u64,
    /// Time spent in the loader phase (microseconds)
    pub loader: u64,
    /// Time spent in the resolver phase (microseconds)
    pub resolver: u64,
    /// Time spent in the checker phase (microseconds)
    pub checker: u64,
    /// Validation statistics
    pub validation: ValidationStats,
    /// Linter statistics
    pub linter: LinterRunStats,
    /// Emitter statistics
    pub emit: EmitStats,
}

/// Validation runtime statistics
#[derive(Debug, Clone, Default)]
pub struct ValidationStats {
    /// Total validation time in microseconds
    pub total: u64,
    /// Per-validator time in microseconds
    pub validators: HashMap<String, u64>,
}

/// Linter runtime statistics
#[derive(Debug, Clone, Default)]
pub struct LinterRunStats {
    /// Total linter time in microseconds
    pub total: u64,
    /// Per-rule time in microseconds
    pub rules: HashMap<String, u64>,
}

/// Emitter runtime statistics
#[derive(Debug, Clone, Default)]
pub struct EmitStats {
    /// Total emit time in microseconds
    pub total: u64,
    /// Per-emitter statistics
    pub emitters: HashMap<String, EmitterRunStats>,
}

/// Per-emitter runtime statistics
#[derive(Debug, Clone, Default)]
pub struct EmitterRunStats {
    /// Total time for this emitter in microseconds
    pub total: u64,
    /// Per-step time in microseconds
    pub steps: HashMap<String, u64>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_stats_default() {
        let stats = Stats::default();
        assert_eq!(stats.complexity.created_types, 0);
        assert_eq!(stats.complexity.finished_types, 0);
        assert_eq!(stats.runtime.total, 0);
    }

    #[test]
    fn test_complexity_stats() {
        let stats = ComplexityStats {
            created_types: 10,
            finished_types: 8,
        };
        assert_eq!(stats.created_types, 10);
        assert_eq!(stats.finished_types, 8);
    }

    #[test]
    fn test_runtime_stats_with_validation() {
        let mut stats = RuntimeStats {
            total: 1000,
            checker: 500,
            ..Default::default()
        };
        stats.validation.total = 200;
        stats
            .validation
            .validators
            .insert("myValidator".to_string(), 200);
        assert_eq!(stats.checker, 500);
        assert_eq!(stats.validation.validators["myValidator"], 200);
    }

    #[test]
    fn test_linter_run_stats() {
        let mut stats = LinterRunStats {
            total: 300,
            ..Default::default()
        };
        stats.rules.insert("unused-using".to_string(), 150);
        stats
            .rules
            .insert("unused-template-parameter".to_string(), 150);
        assert_eq!(stats.rules.len(), 2);
    }

    #[test]
    fn test_emit_stats() {
        let mut stats = EmitStats {
            total: 400,
            ..Default::default()
        };
        let mut emitter = EmitterRunStats {
            total: 400,
            ..Default::default()
        };
        emitter.steps.insert("emit-types".to_string(), 200);
        emitter.steps.insert("emit-operations".to_string(), 200);
        stats.emitters.insert("my-emitter".to_string(), emitter);
        assert_eq!(stats.emitters["my-emitter"].steps.len(), 2);
    }
}