rspack_plugin_javascript 0.103.1

rspack javascript plugin
Documentation
use rspack_cacheable::cacheable;
use rspack_core::EvaluatedInlinableValue;
use rspack_util::{ryu_js, swc::AstSubRangeExt};
use swc_next_ecma_ast::{
  BindingPattern, BindingPatternData, VariableDeclaration, VariableDeclarator, VariableKind,
};

use super::JavascriptParserPlugin;
use crate::{
  Atom,
  utils::eval::{
    BasicEvaluatedExpression, evaluate_to_boolean, evaluate_to_null, evaluate_to_number,
    evaluate_to_string, evaluate_to_undefined,
  },
  visitors::{JavascriptParser, TagInfoData, scope_info::VariableInfoFlags},
};

pub const INLINABLE_CONST_TAG: &str = "inlinable const";

#[derive(Debug, Clone)]
pub struct ConstValueData {
  pub value: ConstValue,
}

#[cacheable]
#[derive(Debug, Clone)]
pub enum ConstValue {
  NoInlinable,
  Inlinable(EvaluatedInlinableValue),
}

impl ConstValue {
  pub fn as_inlinable(&self) -> Option<&EvaluatedInlinableValue> {
    match self {
      ConstValue::Inlinable(v) => Some(v),
      _ => None,
    }
  }
}

#[derive(Default)]
pub struct ConstValuePlugin {
  inline: bool,
}

impl ConstValuePlugin {
  pub fn new(inline: bool) -> Self {
    Self { inline }
  }
}

#[rspack_macros::implemented_javascript_parser_hooks]
impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for ConstValuePlugin {
  fn evaluate_identifier(
    &self,
    parser: &mut JavascriptParser<'p>,
    for_name: &str,
    _member_expr_info: Option<&crate::visitors::ExpressionExpressionInfo>,
    start: u32,
    end: u32,
  ) -> Option<BasicEvaluatedExpression<'p>> {
    if for_name != INLINABLE_CONST_TAG {
      return None;
    }
    // Propagate inlinable constants. Help the rest const variable declarations that referencing the
    // inlinable constants to evaluate to an inlinable constants.
    let tag_info = parser
      .definitions_db
      .expect_get_tag_info(parser.current_tag_info?);
    let data = ConstValueData::downcast(tag_info.data.clone()?);
    let value = match data.value {
      ConstValue::NoInlinable => return None,
      ConstValue::Inlinable(v) => v,
    };
    Some(match value {
      EvaluatedInlinableValue::Null => evaluate_to_null(start, end),
      EvaluatedInlinableValue::Undefined => evaluate_to_undefined(start, end),
      EvaluatedInlinableValue::Boolean(v) => evaluate_to_boolean(v, start, end),
      EvaluatedInlinableValue::Number(v) => evaluate_to_number(v, start, end),
      EvaluatedInlinableValue::String(v) => evaluate_to_string(v.to_string(), start, end),
    })
  }

  fn pre_declarator(
    &self,
    parser: &mut JavascriptParser<'p>,
    declarator: VariableDeclarator,
    declaration: VariableDeclaration,
  ) -> Option<bool> {
    if !parser.is_top_level_scope() {
      return None;
    }
    let ast = parser.ast.ast;
    let init = declarator.init(ast)?;
    if !matches!(declaration.kind(ast), VariableKind::Const) {
      return None;
    }

    let pattern = declarator.id(ast);
    if let Some(name) = pattern.as_binding_identifier(ast) {
      let const_value = if self.inline {
        let evaluated = parser.evaluate_expression(init);
        match to_evaluated_inlinable_value(&evaluated) {
          Some(v) => ConstValue::Inlinable(v),
          None => ConstValue::NoInlinable,
        }
      } else {
        ConstValue::NoInlinable
      };
      tag_const_variable(
        parser,
        Atom::from(ast.get_utf8(name.name(ast))),
        const_value,
      );
    } else {
      tag_const_pattern(parser, pattern);
    }

    None
  }
}

fn tag_const_variable(parser: &mut JavascriptParser, name: Atom, value: ConstValue) {
  parser.tag_variable_with_flags(
    name,
    INLINABLE_CONST_TAG,
    Some(ConstValueData { value }),
    VariableInfoFlags::NORMAL,
  );
}

fn tag_const_pattern(parser: &mut JavascriptParser, pattern: BindingPattern) {
  let ast = parser.ast.ast;
  match ast.binding_pattern_data(pattern) {
    BindingPatternData::BindingIdentifier(identifier) => {
      tag_const_variable(
        parser,
        Atom::from(ast.get_utf8(identifier.name(ast))),
        ConstValue::NoInlinable,
      );
    }
    BindingPatternData::ArrayPattern(array) => {
      for elem in ast.nodes(array.elements(ast)).flatten() {
        tag_const_pattern(parser, elem);
      }
      if let Some(rest) = array.rest(ast) {
        tag_const_pattern(parser, rest.argument(ast));
      }
    }
    BindingPatternData::AssignmentPattern(assignment) => {
      tag_const_pattern(parser, assignment.left(ast));
    }
    BindingPatternData::ObjectPattern(object) => {
      for property in ast.nodes(object.properties(ast)) {
        tag_const_pattern(parser, property.value(ast));
      }
      if let Some(rest) = object.rest(ast) {
        tag_const_pattern(parser, rest.argument(ast));
      }
    }
    BindingPatternData::BindingRestElement(rest) => {
      tag_const_pattern(parser, rest.argument(ast));
    }
    BindingPatternData::SimpleAssignmentTarget(_) => {}
  }
}

pub(super) fn to_evaluated_inlinable_value(
  evaluated: &BasicEvaluatedExpression,
) -> Option<EvaluatedInlinableValue> {
  if evaluated.is_bool() {
    Some(EvaluatedInlinableValue::new_boolean(evaluated.bool()))
  } else if evaluated.is_number()
    && let num = evaluated.number()
    && ryu_js::Buffer::new().format(num).len() <= EvaluatedInlinableValue::SHORT_SIZE
  {
    Some(EvaluatedInlinableValue::new_number(num))
  } else if evaluated.is_string()
    && let str = evaluated.string()
    && str.len() <= EvaluatedInlinableValue::SHORT_SIZE
  {
    Some(EvaluatedInlinableValue::new_string(str.into()))
  } else if evaluated.is_null() {
    Some(EvaluatedInlinableValue::new_null())
  } else if evaluated.is_undefined() {
    Some(EvaluatedInlinableValue::new_undefined())
  } else {
    None
  }
}