vize_l1 0.497.0

L1 - the lossless Vue-template surface tree (codename Sinopia, Davinci P2-7)
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

use oxc_ast::ast::{Comment, CommentKind};
use oxc_diagnostics::{LabeledSpan, OxcCode, OxcDiagnostic, Severity};
use vize_l0::Span;

use super::{SourceError, coordinates::Coordinates};

/// An OXC comment retained by the same parse, with no generated coordinates.
#[derive(Clone, Copy)]
pub struct CommentView<'d, 'a> {
    pub(super) comment: &'d Comment,
    pub(super) coordinates: Coordinates<'a>,
}

impl core::fmt::Debug for CommentView<'_, '_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("CommentView")
            .field("kind", &self.kind())
            .field("decoded", &self.decoded_span())
            .field("authored", &self.authored_span())
            .finish()
    }
}

impl<'a> CommentView<'_, 'a> {
    #[must_use]
    pub const fn kind(self) -> CommentKind {
        self.comment.kind
    }

    pub fn decoded_span(self) -> Result<Span, SourceError> {
        self.coordinates.decoded_span(self.comment.span)
    }

    pub fn authored_span(self) -> Result<Span, SourceError> {
        self.coordinates.source.authored_span(self.decoded_span()?)
    }

    /// Full decoded comment bytes, including delimiters.
    pub fn text(self) -> Result<&'a str, SourceError> {
        let span = self.decoded_span()?;
        self.coordinates
            .source
            .text()
            .get(span.start as usize..span.end as usize)
            .ok_or(SourceError::InvalidDecodedSpan)
    }
}

/// Diagnostic metadata is retained in OXC's original owned record. Only its
/// label locations are exposed through conservative decoded/authored views.
#[derive(Clone, Copy)]
pub struct DiagnosticView<'d, 'a> {
    pub(super) diagnostic: &'d OxcDiagnostic,
    pub(super) coordinates: Coordinates<'a>,
}

impl core::fmt::Debug for DiagnosticView<'_, '_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DiagnosticView")
            .field("message", &self.message())
            .field("severity", &self.severity())
            .field("label_count", &self.diagnostic.labels.len())
            .finish()
    }
}

impl<'d, 'a> DiagnosticView<'d, 'a> {
    #[must_use]
    pub fn message(self) -> &'d str {
        &self.diagnostic.message
    }
    #[must_use]
    pub fn severity(self) -> Severity {
        self.diagnostic.severity
    }
    #[must_use]
    pub fn code(self) -> &'d OxcCode {
        &self.diagnostic.code
    }
    #[must_use]
    pub fn help(self) -> Option<&'d str> {
        self.diagnostic.help.as_deref()
    }
    #[must_use]
    pub fn note(self) -> Option<&'d str> {
        self.diagnostic.note.as_deref()
    }
    #[must_use]
    pub fn url(self) -> Option<&'d str> {
        self.diagnostic.url.as_deref()
    }

    pub fn labels(self) -> impl Iterator<Item = DiagnosticLabel<'d, 'a>> {
        self.diagnostic
            .labels
            .iter()
            .map(move |label| DiagnosticLabel {
                label,
                coordinates: self.coordinates,
            })
    }
}

#[derive(Clone, Copy)]
pub struct DiagnosticLabel<'d, 'a> {
    label: &'d LabeledSpan,
    coordinates: Coordinates<'a>,
}

impl core::fmt::Debug for DiagnosticLabel<'_, '_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DiagnosticLabel")
            .field("message", &self.message())
            .field("decoded", &self.decoded_span())
            .field("authored", &self.authored_span())
            .finish()
    }
}

impl<'d> DiagnosticLabel<'d, '_> {
    #[must_use]
    pub fn message(self) -> Option<&'d str> {
        self.label.label()
    }
    #[must_use]
    pub fn primary(self) -> bool {
        self.label.primary()
    }

    pub fn decoded_span(self) -> Result<Span, SourceError> {
        let start = self.label.offset();
        let end = start
            .checked_add(self.label.len())
            .ok_or(SourceError::SourceTooLarge)?;
        self.coordinates.diagnostic_span(start, end)
    }

    pub fn authored_span(self) -> Result<Span, SourceError> {
        self.coordinates
            .source
            .authored_covering_span(self.decoded_span()?)
    }
}