vize_l1 0.523.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

//! Observe original Vue 1 text callbacks without changing lexer or scope policy.

use super::super::surface::Vue1Policy;
use super::{TextBinding, TextBoundary, TextBoundaryKind, observe};
use crate::dialect::vue::surface::sink::VueSink;
use crate::markup::entity::DecodedEntity;
use crate::markup::token::{LexErrorCode, LexMode, QuoteType, Sink};
use alloc::vec::Vec;
use vize_l0::{Allocator, SourceBlock, Span};

pub(in crate::dialect::vue1) struct TextSink<'a, 'v> {
    pub allocator: &'a Allocator,
    pub block: SourceBlock<'a>,
    pub inner: VueSink<'a, 'v, Vue1Policy>,
    pub bindings: &'v mut Vec<TextBinding<'a>>,
    pub boundaries: &'v mut Vec<TextBoundary>,
}

macro_rules! forward {
    ($($name:ident($($arg:ident: $ty:ty),*);)*) => {
        $(fn $name(&mut self, $($arg: $ty),*) { self.inner.$name($($arg),*); })*
    };
}
impl Sink for TextSink<'_, '_> {
    forward! {
        on_text(start: usize, end: usize);
        on_attrib_data(start: usize, end: usize);
        on_attrib_entity(ch: char, start: usize, end: usize);
        on_attrib_entity_value(value: DecodedEntity, start: usize, end: usize);
        on_attrib_end(quote: QuoteType, end: usize);
        on_attrib_name(start: usize, end: usize);
        on_attrib_name_end(end: usize);
        on_dir_name(start: usize, end: usize);
        on_dir_arg(start: usize, end: usize);
        on_dir_modifier(start: usize, end: usize);
        on_comment(start: usize, end: usize);
        on_in_tag_comment(start: usize, end: usize);
        on_cdata(start: usize, end: usize);
        on_processing_instruction(start: usize, end: usize);
        on_declaration(start: usize, end: usize, terminated: bool);
        on_declaration_recovery(start: usize, end: usize, terminated: bool);
        on_open_tag_name(start: usize, end: usize);
        on_open_tag_end(end: usize);
        on_self_closing_tag(end: usize);
        on_close_tag(start: usize, end: usize);
        on_end();
        on_error(code: LexErrorCode, index: usize);
    }
    fn on_text_entity(&mut self, ch: char, start: usize, end: usize) {
        if matches!(ch, '{' | '}') {
            self.encoded_delimiter(start, end);
        }
        self.inner.on_text_entity(ch, start, end);
    }
    fn on_text_entity_value(&mut self, value: DecodedEntity, start: usize, end: usize) {
        let mut brace = false;
        value.for_each(|ch| brace |= matches!(ch, '{' | '}'));
        if brace {
            self.encoded_delimiter(start, end);
        }
        self.inner.on_text_entity_value(value, start, end);
    }
    fn on_interpolation(&mut self, start: usize, end: usize) {
        self.observe(start, end, false);
        self.inner.on_interpolation(start, end);
    }
    fn on_raw_interpolation(&mut self, start: usize, end: usize) {
        self.observe(start, end, true);
        self.inner.on_raw_interpolation(start, end);
    }
    fn mode(&self) -> LexMode {
        self.inner.mode()
    }

    fn svg_title_children(&self) -> bool {
        self.inner.svg_title_children()
    }
}
impl TextSink<'_, '_> {
    fn observe(&mut self, start: usize, end: usize, raw: bool) {
        if let Some(binding) = observe(self.allocator, self.block, start, end, raw) {
            self.bindings.push(binding);
        } else {
            // Private callbacks should always be authentic UTF-8 windows. Fail
            // closed on an invalid one without inventing replacement bytes.
            self.boundaries.push(TextBoundary {
                span: self.block.span(),
                kind: TextBoundaryKind::SourcePreparation,
            });
        }
    }
    fn encoded_delimiter(&mut self, start: usize, end: usize) {
        // Literal v-pre retains entity spelling without interpretation.
        if self.inner.mode() == LexMode::Verbatim {
            return;
        }
        self.boundaries.push(TextBoundary {
            span: Span::new(
                self.block.start() + start as u32,
                self.block.start() + end as u32,
            ),
            kind: TextBoundaryKind::EncodedDelimiter,
        });
    }
}