oxc_isolated_declarations 0.26.0

A collection of JavaScript tools written in Rust.
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
127

use oxc_allocator::Box;
#[allow(clippy::wildcard_imports)]
use oxc_ast::ast::*;
use oxc_span::{Atom, GetSpan, SPAN};

use crate::{diagnostics::default_export_inferred, IsolatedDeclarations};

impl<'a> IsolatedDeclarations<'a> {
    pub fn transform_export_named_declaration(
        &mut self,
        decl: &ExportNamedDeclaration<'a>,
    ) -> Option<ExportNamedDeclaration<'a>> {
        let decl = self.transform_declaration(decl.declaration.as_ref()?, false)?;

        Some(ExportNamedDeclaration {
            span: decl.span(),
            declaration: Some(decl),
            specifiers: self.ast.vec(),
            source: None,
            export_kind: ImportOrExportKind::Value,
            with_clause: None,
        })
    }

    pub fn create_unique_name(&mut self, name: &str) -> Atom<'a> {
        let mut binding = self.ast.atom(name);
        let mut i = 1;
        while self.scope.has_reference(&binding) {
            binding = self.ast.atom(format!("{name}_{i}").as_str());
            i += 1;
        }
        binding
    }

    pub fn transform_export_default_declaration(
        &mut self,
        decl: &ExportDefaultDeclaration<'a>,
    ) -> Option<(Option<VariableDeclaration<'a>>, ExportDefaultDeclaration<'a>)> {
        let declaration = match &decl.declaration {
            ExportDefaultDeclarationKind::FunctionDeclaration(decl) => self
                .transform_function(decl, Some(false))
                .map(|d| (None, ExportDefaultDeclarationKind::FunctionDeclaration(d))),
            ExportDefaultDeclarationKind::ClassDeclaration(decl) => self
                .transform_class(decl, Some(false))
                .map(|d| (None, ExportDefaultDeclarationKind::ClassDeclaration(d))),
            ExportDefaultDeclarationKind::TSInterfaceDeclaration(_) => {
                // SAFETY: `ast.copy` is unsound! We need to fix.
                Some((None, unsafe { self.ast.copy(&decl.declaration) }))
            }
            expr @ match_expression!(ExportDefaultDeclarationKind) => {
                let expr = expr.to_expression();
                if matches!(expr, Expression::Identifier(_)) {
                    None
                } else {
                    // declare const _default: Type
                    let kind = VariableDeclarationKind::Const;
                    let name = self.create_unique_name("_default");
                    let id = self.ast.binding_pattern_kind_binding_identifier(SPAN, &name);
                    let type_annotation = self
                        .infer_type_from_expression(expr)
                        .map(|ts_type| self.ast.ts_type_annotation(SPAN, ts_type));

                    if type_annotation.is_none() {
                        self.error(default_export_inferred(expr.span()));
                    }

                    let id = self.ast.binding_pattern(id, type_annotation, false);
                    let declarations =
                        self.ast.vec1(self.ast.variable_declarator(SPAN, kind, id, None, true));

                    Some((
                        Some(VariableDeclaration {
                            span: SPAN,
                            kind,
                            declarations,
                            declare: self.is_declare(),
                        }),
                        ExportDefaultDeclarationKind::from(
                            self.ast.expression_identifier_reference(SPAN, &name),
                        ),
                    ))
                }
            }
        };

        declaration.map(|(var_decl, declaration)| {
            let exported =
                ModuleExportName::IdentifierName(self.ast.identifier_name(SPAN, "default"));
            (var_decl, ExportDefaultDeclaration { span: decl.span, declaration, exported })
        })
    }

    pub fn transform_import_declaration(
        &self,
        decl: &ImportDeclaration<'a>,
    ) -> Option<Box<'a, ImportDeclaration<'a>>> {
        let specifiers = decl.specifiers.as_ref()?;

        // SAFETY: `ast.copy` is unsound! We need to fix.
        let mut specifiers = unsafe { self.ast.copy(specifiers) };
        specifiers.retain(|specifier| match specifier {
            ImportDeclarationSpecifier::ImportSpecifier(specifier) => {
                self.scope.has_reference(&specifier.local.name)
            }
            ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => {
                self.scope.has_reference(&specifier.local.name)
            }
            ImportDeclarationSpecifier::ImportNamespaceSpecifier(_) => {
                self.scope.has_reference(&specifier.name())
            }
        });
        if specifiers.is_empty() {
            // We don't need to print this import statement
            None
        } else {
            Some(self.ast.alloc_import_declaration(
                decl.span,
                Some(specifiers),
                // SAFETY: `ast.copy` is unsound! We need to fix.
                unsafe { self.ast.copy(&decl.source) },
                // SAFETY: `ast.copy` is unsound! We need to fix.
                unsafe { self.ast.copy(&decl.with_clause) },
                decl.import_kind,
            ))
        }
    }
}