vize_l4 0.441.0

L4 - the Davinci emission level (codename Stesura): writer, expression rewriting, module assembly and targets
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

//! Append genuine roots directly into the caller's existing Writer.

use super::{VaporError, VaporErrorKind, error, literal, number};
use crate::runtime::{Runtime, vocabulary};
use crate::write::{LinkSink, Writer};
use vize_l3::decision::vapor::{VaporFacts, VaporPart};

pub(super) fn static_roots<L: LinkSink>(
    prelude: &mut Writer<L>,
    render: &mut Writer<L>,
    facts: &VaporFacts<'_, '_>,
) -> Result<(), VaporError> {
    let runtime = vocabulary(Runtime::VueVapor);
    for (index, root) in facts.roots().iter().enumerate() {
        let parts = facts
            .parts(root)
            .ok_or_else(|| error(VaporErrorKind::ForeignRoot))?;
        render.newline();
        render.push("const n");
        number(render, index);
        render.push(" = ");
        let helper = runtime
            .helper("template")
            .ok_or_else(|| error(VaporErrorKind::RuntimeHelper))?;
        prelude.use_helper(helper);
        prelude.push("const t");
        number(prelude, index);
        prelude.push(" = _template(\"");
        if let [VaporPart::Text { text, .. }] = parts {
            prelude.anchor(text.span.start);
            // Actual template() uses a raw Text branch when the first byte
            // is not '<'. L3 refuses that markup-shaped root spelling.
            literal::raw(prelude, text.content);
        } else {
            for part in parts {
                literal::html_part(prelude, part);
            }
        }
        // Actual rc.9 TemplateFlags.STATIC=2 and ROOT=1. L3 decides
        // root fallthrough; the encoder owns the pinned numeric spelling.
        prelude.push(if facts.inherit_attrs() == Some(root.node()) {
            "\", 3)\n"
        } else {
            "\", 2)\n"
        });
        render.push("t");
        number(render, index);
        render.push("()");
    }
    Ok(())
}

pub(super) fn return_roots<L: LinkSink>(render: &mut Writer<L>, count: usize) {
    render.newline();
    render.push("return ");
    if count != 1 {
        render.push("[");
    }
    for index in 0..count {
        if index != 0 {
            render.push(", ");
        }
        render.push("n");
        number(render, index);
    }
    if count != 1 {
        render.push("]");
    }
}