vize_l4 0.504.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
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Statically selected expression writers; the caller cannot supply a file policy.

use vize_l0::id::NodeId;
use vize_l2::{
    expr::ExprRef,
    op::{OnOp, OriginalForOp},
};
use vize_l3::decision::NativeAnalysis;

use super::{DomError, DomErrorKind};
use crate::expr::{AccessProvider, ResolvedExpressions};
use crate::write::{LinkSink, Writer};

pub(super) trait ExpressionWriter {
    fn write_for_collection<L: LinkSink>(
        &self,
        _: &mut Writer<L>,
        node: NodeId,
        original: &OriginalForOp<'_>,
    ) -> Result<(), DomError> {
        Err(DomError {
            node: Some(node),
            span: original.span,
            kind: DomErrorKind::RuntimeAccessUnavailable,
        })
    }
    fn write_handler<L: LinkSink>(
        &self,
        _: &mut Writer<L>,
        node: NodeId,
        on: &OnOp<'_>,
    ) -> Result<(), DomError> {
        Err(DomError {
            node: Some(node),
            span: on.span,
            kind: DomErrorKind::RuntimeAccessUnavailable,
        })
    }
    fn write<L: LinkSink>(
        &self,
        writer: &mut Writer<L>,
        node: NodeId,
        expression: ExprRef<'_>,
    ) -> Result<(), DomError>;
}

// The previous bare-artifact contract remains distinct from the genuine file
// entry. It never supplies runtime access to a file-owned analysis.
pub(super) struct BareExpressions<'s, 'owner, 'arena, A: AccessProvider> {
    pub analysis: &'s NativeAnalysis<'owner, 'arena>,
    pub expressions: ResolvedExpressions<'s, 'arena>,
    pub access: &'s A,
}

impl<A: AccessProvider> ExpressionWriter for BareExpressions<'_, '_, '_, A> {
    fn write<L: LinkSink>(
        &self,
        writer: &mut Writer<L>,
        node: NodeId,
        expression: ExprRef<'_>,
    ) -> Result<(), DomError> {
        let ExprRef::Js(retained) = expression else {
            return Err(DomError {
                node: Some(node),
                span: expression.span(),
                kind: DomErrorKind::UnsupportedExpression,
            });
        };
        self.expressions
            .write_retained(
                writer,
                self.analysis.artifact().source(),
                retained,
                self.access,
            )
            .map_err(|error| DomError {
                node: Some(node),
                span: error.span,
                kind: DomErrorKind::Expression(error),
            })
    }
}