svelte-compiler 0.1.4

Core compiler API for the Rust Svelte toolchain
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

use crate::ast::modern::{EachBlock, Expression, SnippetBlock};
use crate::names::{Name, NameSet};

#[derive(Debug, Default)]
pub(crate) struct ScopeStack {
    frames: Vec<NameSet>,
}

impl ScopeStack {
    pub(crate) fn push(&mut self, frame: NameSet) {
        self.frames.push(frame);
    }

    pub(crate) fn pop(&mut self) {
        let _ = self.frames.pop();
    }

    pub(crate) fn contains(&self, name: &str) -> bool {
        self.frames.iter().rev().any(|frame| frame.contains(name))
    }

    pub(crate) fn with_frame<T>(
        &mut self,
        frame: NameSet,
        visit: impl FnOnce(&mut Self) -> T,
    ) -> T {
        self.push(frame);
        let result = visit(self);
        self.pop();
        result
    }
}

pub(crate) fn extend_name_set_with_oxc_pattern_bindings(
    names: &mut NameSet,
    pattern: &oxc_ast::ast::BindingPattern<'_>,
) {
    collect_oxc_pattern_binding_names(pattern, names);
}

pub(crate) fn extend_name_set_with_expression_pattern_bindings(
    names: &mut NameSet,
    expression: &Expression,
) {
    if let Some(pattern) = expression.oxc_pattern() {
        extend_name_set_with_oxc_pattern_bindings(names, pattern);
    }
}

pub(crate) fn extend_name_set_with_optional_name(names: &mut NameSet, name: Option<&Name>) {
    if let Some(name) = name {
        names.insert(name.clone());
    }
}

pub(crate) fn scope_frame_for_each_block(block: &EachBlock) -> NameSet {
    let mut names = NameSet::default();
    if let Some(context) = block.context.as_ref() {
        extend_name_set_with_expression_pattern_bindings(&mut names, context);
    }
    extend_name_set_with_optional_name(&mut names, block.index.as_ref());
    names
}

pub(crate) fn scope_frame_for_snippet_block(block: &SnippetBlock) -> NameSet {
    let mut names = NameSet::default();
    for parameter in &block.parameters {
        extend_name_set_with_expression_pattern_bindings(&mut names, parameter);
    }
    names
}

fn collect_oxc_pattern_binding_names(pattern: &oxc_ast::ast::BindingPattern<'_>, names: &mut NameSet) {
    match pattern {
        oxc_ast::ast::BindingPattern::BindingIdentifier(identifier) => {
            names.insert(identifier.name.as_str().into());
        }
        oxc_ast::ast::BindingPattern::AssignmentPattern(pattern) => {
            collect_oxc_pattern_binding_names(&pattern.left, names);
        }
        oxc_ast::ast::BindingPattern::ObjectPattern(pattern) => {
            for property in &pattern.properties {
                collect_oxc_pattern_binding_names(&property.value, names);
            }
            if let Some(rest) = pattern.rest.as_ref() {
                collect_oxc_pattern_binding_names(&rest.argument, names);
            }
        }
        oxc_ast::ast::BindingPattern::ArrayPattern(pattern) => {
            for element in pattern.elements.iter().flatten() {
                collect_oxc_pattern_binding_names(element, names);
            }
            if let Some(rest) = pattern.rest.as_ref() {
                collect_oxc_pattern_binding_names(&rest.argument, names);
            }
        }
    }
}