vize_l2 0.440.0

L2 - the Davinci semantic IR (codename Disegno): the neutral op family every input dialect lowers into
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

//! Internal reference events; binding policy runs in the owning sink.

use alloc::vec::Vec;
use vize_l0::Span;

use super::{BindingLookup, Occurrence, ResolutionError, ResolutionErrorKind, Usage, walk};
use crate::expr::JsExpr;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ReferenceEvent<'a> {
    span: Span,
    name: &'a str,
    usage: Usage,
    shorthand: bool,
    constructor: bool,
}

impl<'a> ReferenceEvent<'a> {
    pub(super) fn new(
        span: Span,
        name: &'a str,
        usage: Usage,
        shorthand: bool,
        constructor: bool,
    ) -> Self {
        Self {
            span,
            name,
            usage,
            shorthand,
            constructor,
        }
    }

    #[must_use]
    pub(crate) const fn span(self) -> Span {
        self.span
    }
    #[must_use]
    pub(crate) const fn name(self) -> &'a str {
        self.name
    }
    #[must_use]
    pub(crate) const fn usage(self) -> Usage {
        self.usage
    }
    #[must_use]
    pub(crate) const fn shorthand(self) -> bool {
        self.shorthand
    }
    #[must_use]
    pub(crate) const fn constructor(self) -> bool {
        self.constructor
    }
}

pub(crate) trait ReferenceSink<'a> {
    type Checkpoint;
    fn checkpoint(&self) -> Self::Checkpoint;
    fn reference(&mut self, event: ReferenceEvent<'a>) -> Result<(), ResolutionErrorKind>;
    fn observe_syntax(
        &mut self,
        _kind: super::SyntaxKind<'a>,
        _edge: super::SyntaxEdge,
        _span: Span,
    ) -> Result<(), ResolutionErrorKind> {
        Ok(())
    }
    fn observe_invocation(
        &mut self,
        _expression: &oxc_ast::ast::Expression<'a>,
        _span: Span,
    ) -> Result<(), ResolutionErrorKind> {
        Ok(())
    }
    fn observe_call(
        &mut self,
        _call: &oxc_ast::ast::CallExpression<'a>,
        _span: Span,
    ) -> Result<(), ResolutionErrorKind> {
        Ok(())
    }
    fn rollback(&mut self, checkpoint: Self::Checkpoint);
}

pub(super) fn resolve<'a>(
    expression: &JsExpr<'a>,
    bindings: &impl BindingLookup,
) -> Result<Vec<Occurrence<'a>>, ResolutionError> {
    let mut sink = Immediate {
        bindings,
        occurrences: Vec::new(),
    };
    walk::expression(expression, &mut sink)?;
    Ok(sink.occurrences)
}

struct Immediate<'a, 'b, B> {
    bindings: &'b B,
    occurrences: Vec<Occurrence<'a>>,
}

impl<'a, B: BindingLookup> ReferenceSink<'a> for Immediate<'a, '_, B> {
    type Checkpoint = usize;
    fn checkpoint(&self) -> usize {
        self.occurrences.len()
    }
    fn reference(&mut self, event: ReferenceEvent<'a>) -> Result<(), ResolutionErrorKind> {
        let binding = self
            .bindings
            .lookup(event.name())
            .ok_or(ResolutionErrorKind::MissingBinding)?;
        self.occurrences.push(Occurrence {
            span: event.span(),
            name: event.name(),
            binding,
            usage: event.usage(),
            shorthand: event.shorthand(),
            constructor: event.constructor(),
        });
        Ok(())
    }
    fn rollback(&mut self, checkpoint: usize) {
        self.occurrences.truncate(checkpoint);
    }
}