rspack_plugin_javascript 0.103.0-rc.0

rspack javascript plugin
Documentation
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)
          {
            // Semantic bindings are already active; run declaration hooks in
            // the block so runtime-name collisions are handled in that scope.
            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);
      }
    }
  }
}