use rspack_util::swc::AstSubRangeExt;
use swc_next_ecma_ast::{
Decl, ExportDefaultDeclarationKindData, ExprData, GetSpan, NodeKindData, Stmt, StmtData,
SubRange, VariableDeclaration, VariableKind,
};
use super::{
JavascriptParser,
estree::{ExportDefaultDeclaration, ExportLocal, ExportNamedDeclaration},
};
use crate::{Atom, JS_DEFAULT_KEYWORD, parser_plugin::JavascriptParserPlugin};
impl JavascriptParser<'_> {
pub fn block_pre_walk_module_items(&mut self, statements: SubRange<Stmt>) {
let ast = self.ast.ast;
for statement in ast.nodes(statements) {
self.block_pre_walk_module_item(statement);
}
}
pub fn block_pre_walk_statements(&mut self, statements: SubRange<Stmt>) {
let ast = self.ast.ast;
for statement in ast.nodes(statements) {
self.block_pre_walk_statement(statement);
}
}
pub fn block_pre_walk_module_item(&mut self, statement: Stmt) {
let ast = self.ast.ast;
match ast.stmt_data(statement) {
StmtData::ImportDeclaration(_)
| StmtData::ExportAllDeclaration(_)
| StmtData::ExportNamedDeclaration(_)
| StmtData::ExportDefaultDeclaration(_) => {
let drive = self.plugin_drive();
self.enter_statement(
statement.span(ast),
statement,
|parser, node| {
drive
.block_pre_module_declaration(parser, node)
.unwrap_or_default()
},
|parser, node| match parser.ast.ast.stmt_data(node) {
StmtData::ExportNamedDeclaration(declaration) => {
parser.block_pre_walk_export_named_declaration(ExportNamedDeclaration(declaration))
}
StmtData::ExportDefaultDeclaration(declaration) => parser
.block_pre_walk_export_default_declaration(ExportDefaultDeclaration(declaration)),
_ => (),
},
);
}
_ => self.block_pre_walk_statement(statement),
}
}
pub fn block_pre_walk_statement(&mut self, statement: Stmt) {
let drive = self.plugin_drive();
self.enter_statement(
statement.span(self.ast.ast),
statement,
|parser, node| drive.block_pre_statement(parser, node).unwrap_or_default(),
|parser, node| match parser.ast.ast.kind_data(node.node_id()) {
NodeKindData::VariableDeclaration(declaration) => {
parser.block_pre_walk_variable_declaration(declaration)
}
NodeKindData::Function(function) => {
if parser.is_block_scoped_function(function)
&& let Some(identifier) = function.id(parser.ast.ast)
{
parser.enter_ident(identifier, |_, _, _| {});
}
}
NodeKindData::ExpressionStatement(expression) => {
parser.block_pre_walk_expression_statement(expression)
}
_ => (),
},
);
}
fn block_pre_walk_expression_statement(
&mut self,
statement: swc_next_ecma_ast::ExpressionStatement,
) {
let expression = statement.expression(self.ast.ast);
if let ExprData::AssignmentExpression(assignment) = self.ast.ast.expr_data(expression) {
self.pre_walk_assignment_expression(assignment);
}
}
pub(super) fn block_pre_walk_variable_declaration(&mut self, declaration: VariableDeclaration) {
if declaration.kind(self.ast.ast) != VariableKind::Var {
self._pre_walk_variable_declaration(declaration);
}
}
fn block_pre_walk_export_named_declaration(&mut self, export: ExportNamedDeclaration) {
let ast = self.ast.ast;
if export.source(ast).is_some() {
return;
}
let drive = self.plugin_drive();
drive.export(self, ExportLocal::Named(export));
if let Some(declaration) = export.0.declaration(ast) {
let statement = Stmt::Declaration(declaration);
let prev = self.prev_statement;
self.pre_walk_statement(statement);
self.prev_statement = prev;
self.block_pre_walk_statement(statement);
self.enter_declaration(declaration, |parser, identifier, name| {
let ast = parser.ast.ast;
let name = Atom::from(name);
drive.export_specifier(
parser,
ExportLocal::Named(export),
&name,
&name,
identifier.span(ast),
);
});
} else {
for (local, exported, span) in export.named_export_specifiers(ast) {
drive.export_specifier(self, ExportLocal::Named(export), &local, &exported, span);
}
}
}
fn block_pre_walk_export_default_declaration(&mut self, export: ExportDefaultDeclaration) {
let ast = self.ast.ast;
let drive = self.plugin_drive();
drive.export(self, ExportLocal::Default(export));
let declaration = export.declaration(ast);
match ast.export_default_declaration_kind_data(declaration) {
ExportDefaultDeclarationKindData::Class(class) => {
let statement = Stmt::Declaration(Decl::Class(class));
let prev = self.prev_statement;
self.pre_walk_statement(statement);
self.prev_statement = prev;
self.block_pre_walk_statement(statement);
if let Some(identifier) = class.id(ast) {
drive.export_specifier(
self,
ExportLocal::Default(export),
&Atom::from(ast.get_utf8(identifier.name(ast))),
&JS_DEFAULT_KEYWORD,
identifier.span(ast),
);
} else {
drive.export_expression(self, export, declaration);
}
}
ExportDefaultDeclarationKindData::Function(function) => {
let statement = Stmt::Declaration(Decl::Function(function));
let prev = self.prev_statement;
self.pre_walk_statement(statement);
self.prev_statement = prev;
self.block_pre_walk_statement(statement);
if let Some(identifier) = function.id(ast) {
drive.export_specifier(
self,
ExportLocal::Default(export),
&Atom::from(ast.get_utf8(identifier.name(ast))),
&JS_DEFAULT_KEYWORD,
identifier.span(ast),
);
} else {
drive.export_expression(self, export, declaration);
}
}
_ => {
drive.export_expression(self, export, declaration);
}
}
}
}