vize_atelier_sfc 0.76.0

Atelier SFC - The Single File Component workshop for Vize
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

//! Runtime binding collection for script-level macro disambiguation.

use oxc_ast::ast::{
    BindingPattern, Declaration, ImportDeclarationSpecifier, Statement, VariableDeclaration,
};
use vize_carton::{FxHashSet, String};

pub(super) fn collect_runtime_bindings<'a>(
    statements: impl Iterator<Item = &'a Statement<'a>>,
) -> FxHashSet<String> {
    let mut bindings = FxHashSet::default();

    for stmt in statements {
        collect_runtime_bindings_from_statement(stmt, &mut bindings);
    }

    bindings
}

fn collect_runtime_bindings_from_statement(stmt: &Statement<'_>, bindings: &mut FxHashSet<String>) {
    match stmt {
        Statement::ImportDeclaration(import_decl) => {
            if import_decl.import_kind.is_type() {
                return;
            }
            if let Some(specifiers) = import_decl.specifiers.as_ref() {
                for specifier in specifiers {
                    match specifier {
                        ImportDeclarationSpecifier::ImportSpecifier(spec) => {
                            if !spec.import_kind.is_type() {
                                bindings.insert(spec.local.name.as_str().into());
                            }
                        }
                        ImportDeclarationSpecifier::ImportDefaultSpecifier(spec) => {
                            bindings.insert(spec.local.name.as_str().into());
                        }
                        ImportDeclarationSpecifier::ImportNamespaceSpecifier(spec) => {
                            bindings.insert(spec.local.name.as_str().into());
                        }
                    }
                }
            }
        }
        Statement::VariableDeclaration(var_decl) => {
            collect_variable_declaration_bindings(var_decl, bindings);
        }
        Statement::FunctionDeclaration(func) => {
            if let Some(id) = func.id.as_ref() {
                bindings.insert(id.name.as_str().into());
            }
        }
        Statement::ClassDeclaration(class) => {
            if let Some(id) = class.id.as_ref() {
                bindings.insert(id.name.as_str().into());
            }
        }
        Statement::ExportNamedDeclaration(export_decl) => {
            if export_decl.export_kind.is_type() {
                return;
            }
            if let Some(declaration) = export_decl.declaration.as_ref() {
                collect_runtime_bindings_from_declaration(declaration, bindings);
            }
        }
        _ => {}
    }
}

fn collect_runtime_bindings_from_declaration(
    declaration: &Declaration<'_>,
    bindings: &mut FxHashSet<String>,
) {
    match declaration {
        Declaration::VariableDeclaration(var_decl) => {
            collect_variable_declaration_bindings(var_decl, bindings);
        }
        Declaration::FunctionDeclaration(func) => {
            if let Some(id) = func.id.as_ref() {
                bindings.insert(id.name.as_str().into());
            }
        }
        Declaration::ClassDeclaration(class) => {
            if let Some(id) = class.id.as_ref() {
                bindings.insert(id.name.as_str().into());
            }
        }
        _ => {}
    }
}

fn collect_variable_declaration_bindings(
    var_decl: &VariableDeclaration<'_>,
    bindings: &mut FxHashSet<String>,
) {
    for declarator in var_decl.declarations.iter() {
        collect_binding_pattern_names(&declarator.id, bindings);
    }
}

fn collect_binding_pattern_names(pattern: &BindingPattern<'_>, bindings: &mut FxHashSet<String>) {
    match pattern {
        BindingPattern::BindingIdentifier(id) => {
            bindings.insert(id.name.as_str().into());
        }
        BindingPattern::ObjectPattern(obj) => {
            for prop in obj.properties.iter() {
                collect_binding_pattern_names(&prop.value, bindings);
            }
            if let Some(rest) = obj.rest.as_ref() {
                collect_binding_pattern_names(&rest.argument, bindings);
            }
        }
        BindingPattern::ArrayPattern(arr) => {
            for element in arr.elements.iter().flatten() {
                collect_binding_pattern_names(element, bindings);
            }
            if let Some(rest) = arr.rest.as_ref() {
                collect_binding_pattern_names(&rest.argument, bindings);
            }
        }
        BindingPattern::AssignmentPattern(assign) => {
            collect_binding_pattern_names(&assign.left, bindings);
        }
    }
}