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;
}
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::format_number_literal(&mut ryu_js::Buffer::new(), 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
}
}