rspack_plugin_javascript 0.103.2

rspack javascript plugin
Documentation
use rspack_util::{
  SpanExt,
  swc::{AstSubRangeExt, PropertyKeyValue, classify_property_key},
};
use swc_next_ecma_ast::*;

use super::{DestructuringAssignmentProperty, JavascriptParser, PatRef};
use crate::{
  Atom, parser_plugin::JavascriptParserPlugin, utils::eval::BasicEvaluatedExpression,
  visitors::DestructuringAssignmentProperties,
};

fn eval_property_key<'parser>(
  parser: &mut JavascriptParser<'parser>,
  key: PropertyKey,
) -> BasicEvaluatedExpression<'parser> {
  let ast = parser.ast.ast;
  let span = key.span(ast);
  let mut evaluated = BasicEvaluatedExpression::with_range(span.real_lo(), span.real_hi());
  match classify_property_key(ast, key) {
    PropertyKeyValue::StringLiteral(string) => {
      evaluated.set_string(ast.get_wtf8(string.value(ast)).to_string_lossy());
    }
    PropertyKeyValue::NumericLiteral(number) => evaluated.set_number(number.value(ast)),
    PropertyKeyValue::BigIntLiteral(bigint) => {
      if let Some(value) = bigint.value(ast) {
        evaluated.set_bigint(value);
      }
    }
    PropertyKeyValue::IdentifierName(identifier) => {
      evaluated.set_string(ast.get_utf8(identifier.name(ast)));
    }
    PropertyKeyValue::PrivateIdentifier(identifier) => {
      evaluated.set_string(ast.get_utf8(identifier.name(ast)));
    }
    PropertyKeyValue::OtherExpr(expression) => return parser.evaluate_expression(expression),
  }
  evaluated
}

impl JavascriptParser<'_> {
  pub fn pre_walk_module_items(&mut self, statements: SubRange<Stmt>) {
    let ast = self.ast.ast;
    for statement in ast.nodes(statements) {
      self.pre_walk_module_item(statement);
    }
  }

  pub fn pre_walk_statements(&mut self, statements: SubRange<Stmt>) {
    let ast = self.ast.ast;
    for statement in ast.nodes(statements) {
      self.pre_walk_statement(statement);
    }
  }

  fn pre_walk_module_item(&mut self, statement: Stmt) {
    match self.ast.ast.stmt_data(statement) {
      StmtData::ImportDeclaration(_)
      | StmtData::ExportNamedDeclaration(_)
      | StmtData::ExportDefaultDeclaration(_)
      | StmtData::ExportAllDeclaration(_) => self.is_esm = true,
      _ => self.pre_walk_statement(statement),
    }
  }

  pub fn pre_walk_statement(&mut self, statement: Stmt) {
    let drive = self.plugin_drive();
    self.enter_statement(
      statement.span(self.ast.ast),
      statement,
      |parser, node| {
        // Lexical block functions belong to the block pass. Hoisting hooks
        // would otherwise register them in the enclosing scope.
        if let NodeKindData::Function(function) = parser.ast.ast.kind_data(node.node_id())
          && parser.is_block_scoped_function(function)
        {
          return true;
        }
        drive.pre_statement(parser, node).unwrap_or_default()
      },
      |parser, node| match parser.ast.ast.kind_data(node.node_id()) {
        NodeKindData::BlockStatement(stmt) => parser.pre_walk_block_statement(stmt),
        NodeKindData::DoWhileStatement(stmt) => parser.pre_walk_do_while_statement(stmt),
        NodeKindData::ForInStatement(stmt) => parser.pre_walk_for_in_statement(stmt),
        NodeKindData::ForOfStatement(stmt) => parser.pre_walk_for_of_statement(stmt),
        NodeKindData::ForStatement(stmt) => parser.pre_walk_for_statement(stmt),
        NodeKindData::VariableDeclaration(stmt) => parser.pre_walk_variable_declaration(stmt),
        NodeKindData::IfStatement(stmt) => parser.pre_walk_if_statement(stmt),
        NodeKindData::LabeledStatement(stmt) => parser.pre_walk_labeled_statement(stmt),
        NodeKindData::SwitchStatement(stmt) => parser.pre_walk_switch_statement(stmt),
        NodeKindData::TryStatement(stmt) => parser.pre_walk_try_statement(stmt),
        NodeKindData::WhileStatement(stmt) => parser.pre_walk_while_statement(stmt),
        NodeKindData::WithStatement(stmt) => parser.pre_walk_with_statement(stmt),
        _ => (),
      },
    );
  }

  pub(super) fn is_block_scoped_function(&self, function: Function) -> bool {
    let ast = self.ast.ast;
    let Some(identifier) = function.id(ast) else {
      return false;
    };
    let semantic = self.ast.semantic;
    let Some(symbol) = semantic.symbol_of(identifier.node_id()) else {
      return false;
    };
    let scope_id = semantic.scope_of_symbol(symbol);
    let scope = semantic.scope(scope_id);
    let hoist_target = scope.hoist_target;
    if scope_id == hoist_target {
      return false;
    }
    // These functions cannot have an Annex B companion binding.
    if scope.flags.strict || function.r#async(ast) || function.generator(ast) {
      return true;
    }
    // SWC records an eligible Annex B function's companion var declaration
    // at the same identifier node, separately from its lexical block symbol.
    let name = ast.get_utf8(identifier.name(ast));
    !semantic
      .binding(hoist_target, name.as_bytes())
      .is_some_and(|symbol| {
        semantic.declarations(symbol).any(|declaration| {
          declaration.scope == hoist_target && declaration.node == identifier.node_id()
        })
      })
  }

  fn pre_walk_with_statement(&mut self, stmt: WithStatement) {
    self.pre_walk_statement(stmt.body(self.ast.ast));
  }

  fn pre_walk_while_statement(&mut self, stmt: WhileStatement) {
    self.pre_walk_statement(stmt.body(self.ast.ast));
  }

  fn pre_walk_catch_clause(&mut self, clause: CatchClause) {
    self.pre_walk_statement(Stmt::BlockStatement(clause.body(self.ast.ast)));
  }

  fn pre_walk_try_statement(&mut self, stmt: TryStatement) {
    let ast = self.ast.ast;
    self.pre_walk_statement(Stmt::BlockStatement(stmt.block(ast)));
    if let Some(handler) = stmt.handler(ast) {
      self.pre_walk_catch_clause(handler);
    }
    if let Some(finalizer) = stmt.finalizer(ast) {
      self.pre_walk_statement(Stmt::BlockStatement(finalizer));
    }
  }

  fn pre_walk_switch_statement(&mut self, stmt: SwitchStatement) {
    let ast = self.ast.ast;
    for case in ast.nodes(stmt.cases(ast)) {
      self.pre_walk_statements(case.consequent(ast));
    }
  }

  fn pre_walk_labeled_statement(&mut self, stmt: LabeledStatement) {
    self.pre_walk_statement(stmt.body(self.ast.ast));
  }

  fn pre_walk_if_statement(&mut self, stmt: IfStatement) {
    let ast = self.ast.ast;
    self.pre_walk_statement(stmt.consequent(ast));
    if let Some(alternate) = stmt.alternate(ast) {
      self.pre_walk_statement(alternate);
    }
  }

  fn pre_walk_for_statement(&mut self, stmt: ForStatement) {
    let ast = self.ast.ast;
    if let Some(init) = stmt.init(ast)
      && let ForStatementInitData::VariableDeclaration(declaration) =
        ast.for_statement_init_data(init)
    {
      self.pre_walk_statement(Stmt::Declaration(Decl::VariableDeclaration(declaration)));
    }
    self.pre_walk_statement(stmt.body(ast));
  }

  fn pre_walk_for_head(&mut self, head: ForStatementLeft) {
    if let ForStatementLeftData::VariableDeclaration(declaration) =
      self.ast.ast.for_statement_left_data(head)
    {
      self.pre_walk_variable_declaration(declaration);
    }
  }

  fn pre_walk_for_of_statement(&mut self, stmt: ForOfStatement) {
    let ast = self.ast.ast;
    if stmt.r#await(ast) && self.is_top_level_scope() {
      self.plugin_drive().top_level_for_of_await_stmt(self, stmt);
    }
    self.pre_walk_for_head(stmt.left(ast));
    self.pre_walk_statement(stmt.body(ast));
  }

  pub(super) fn pre_walk_block_statement(&mut self, stmt: BlockStatement) {
    let ast = self.ast.ast;
    self.pre_walk_statements(stmt.body(ast));
  }

  fn pre_walk_do_while_statement(&mut self, stmt: DoWhileStatement) {
    self.pre_walk_statement(stmt.body(self.ast.ast));
  }

  fn pre_walk_for_in_statement(&mut self, stmt: ForInStatement) {
    let ast = self.ast.ast;
    self.pre_walk_for_head(stmt.left(ast));
    self.pre_walk_statement(stmt.body(ast));
  }

  fn pre_walk_variable_declaration(&mut self, decl: VariableDeclaration) {
    if decl.kind(self.ast.ast) == VariableKind::Var {
      self._pre_walk_variable_declaration(decl);
    }
  }

  pub(super) fn _pre_walk_variable_declaration(&mut self, decl: VariableDeclaration) {
    let drive = self.plugin_drive();
    let ast = self.ast.ast;
    for declarator in ast.nodes(decl.declarators(ast)) {
      self.pre_walk_variable_declarator(declarator);
      if !drive
        .pre_declarator(self, declarator, decl)
        .unwrap_or_default()
      {
        self.enter_pattern(PatRef::Borrowed(declarator.id(ast)), |_, _, _| {});
      }
    }
  }

  pub(crate) fn collect_destructuring_assignment_properties(
    &mut self,
    pattern: BindingPattern,
  ) -> Option<DestructuringAssignmentProperties> {
    let ast = self.ast.ast;
    if let Some(object) = pattern.as_object_pattern(ast) {
      return self.collect_destructuring_assignment_properties_from_object_pattern(object);
    }
    if let Some(array) = pattern.as_array_pattern(ast) {
      return self.collect_destructuring_assignment_properties_from_array_pattern(array);
    }
    None
  }

  pub(crate) fn collect_destructuring_assignment_properties_from_object_pattern(
    &mut self,
    object: ObjectPattern,
  ) -> Option<DestructuringAssignmentProperties> {
    let ast = self.ast.ast;
    if object.rest(ast).is_some() {
      return None;
    }
    let mut keys = DestructuringAssignmentProperties::default();
    for property in ast.nodes(object.properties(ast)) {
      let key = property.key(ast);
      let value = property.value(ast);
      let (id, shorthand) = if property.shorthand(ast) {
        let identifier = value.as_binding_identifier(ast).or_else(|| {
          value
            .as_assignment_pattern(ast)
            .and_then(|assignment| assignment.left(ast).as_binding_identifier(ast))
        })?;
        (Atom::from(ast.get_utf8(identifier.name(ast))), true)
      } else {
        let evaluated = eval_property_key(self, key);
        (Atom::from(evaluated.as_string()?), false)
      };
      keys.insert(DestructuringAssignmentProperty {
        id,
        range: key.span(ast).into(),
        pattern: self.collect_destructuring_assignment_properties(value),
        shorthand,
      });
    }
    Some(keys)
  }

  pub(crate) fn collect_destructuring_assignment_properties_from_array_pattern(
    &mut self,
    array: ArrayPattern,
  ) -> Option<DestructuringAssignmentProperties> {
    let ast = self.ast.ast;
    if array.rest(ast).is_some() {
      return None;
    }
    let mut keys = DestructuringAssignmentProperties::default();
    let mut buffer = rspack_util::itoa::Buffer::new();
    for (index, element) in ast.nodes(array.elements(ast)).enumerate() {
      let Some(element) = element else {
        continue;
      };
      keys.insert(DestructuringAssignmentProperty {
        id: buffer.format(index).into(),
        range: element.span(ast).into(),
        pattern: self.collect_destructuring_assignment_properties(element),
        shorthand: false,
      });
    }
    Some(keys)
  }

  fn pre_walk_variable_declarator(&mut self, declarator: VariableDeclarator) {
    let ast = self.ast.ast;
    let Some(init) = declarator.init(ast) else {
      return;
    };
    let Some(object) = declarator.id(ast).as_object_pattern(ast) else {
      return;
    };
    self.enter_destructuring_assignment(object, init);
  }

  pub(crate) fn pre_walk_assignment_expression(&mut self, assign: AssignmentExpression) {
    let ast = self.ast.ast;
    if let Some(object) = assign.left(ast).as_object_assignment_target(ast) {
      self.enter_destructuring_assignment(object, assign.right(ast));
    }
  }
}