fix: transformation

Author: kermanx

crates/jsshaker/src/nodes/expr/literals.rs

@@ -1,13 +1,13 @@
 use oxc::ast::ast::{
-  BigIntLiteral, BooleanLiteral, NullLiteral, NumberBase, NumericLiteral, RegExpLiteral,
-  StringLiteral,
+  BigIntLiteral, BooleanLiteral, Expression, NullLiteral, NumberBase, NumericLiteral,
+  RegExpLiteral, StringLiteral,
 };
 
-use crate::{Analyzer, entity::Entity, utils::ast::AstKind2};
+use crate::{Analyzer, entity::Entity, transformer::Transformer, utils::ast::AstKind2};
 
 impl<'a> Analyzer<'a> {
   pub fn exec_string_literal(&mut self, node: &'a StringLiteral) -> Entity<'a> {
-    self.mangler.use_constant_node(AstKind2::StringLiteral(node), &node.value).into()
+    self.exec_mangable_static_string(AstKind2::StringLiteral(node), &node.value)
   }
 
   pub fn exec_numeric_literal(&mut self, node: &'a NumericLiteral) -> Entity<'a> {
@@ -34,3 +34,20 @@ impl<'a> Analyzer<'a> {
     self.factory.unknown
   }
 }
+
+impl<'a> Transformer<'a> {
+  pub fn transform_string_literal(
+    &self,
+    node: &'a StringLiteral,
+    need_val: bool,
+  ) -> Option<Expression<'a>> {
+    let StringLiteral { span, value, .. } = node;
+    need_val.then(|| {
+      self.ast.expression_string_literal(
+        *span,
+        self.transform_mangable_static_string(AstKind2::StringLiteral(node), value),
+        None,
+      )
+    })
+  }
+}

crates/jsshaker/src/nodes/expr/mod.rs

@@ -125,8 +125,8 @@ impl<'a> Transformer<'a> {
       match_member_expression!(Expression) => {
         self.transform_member_expression_read(node.to_member_expression(), need_val)
       }
-      Expression::StringLiteral(_)
-      | Expression::NumericLiteral(_)
+      Expression::StringLiteral(node) => self.transform_string_literal(node, need_val),
+      Expression::NumericLiteral(_)
       | Expression::BigIntLiteral(_)
       | Expression::BooleanLiteral(_)
       | Expression::NullLiteral(_)

crates/jsshaker/src/nodes/expr/template_literal.rs

@@ -1,14 +1,10 @@
-use std::mem;
-
 use oxc::{
   allocator::FromIn,
   ast::ast::{Expression, TemplateElementValue, TemplateLiteral},
-  span::{Atom, GetSpan, SPAN},
+  span::Atom,
 };
 
-use crate::{
-  analyzer::Analyzer, build_effect, entity::Entity, transformer::Transformer, utils::ast::AstKind2,
-};
+use crate::{analyzer::Analyzer, build_effect, entity::Entity, transformer::Transformer};
 
 impl<'a> Analyzer<'a> {
   pub fn exec_template_literal(&mut self, node: &'a TemplateLiteral<'a>) -> Entity<'a> {
@@ -36,52 +32,19 @@ impl<'a> Transformer<'a> {
       let mut quasis_iter = quasis.into_iter();
       let mut transformed_exprs = self.ast.vec();
       let mut transformed_quasis = vec![];
-      let mut pending_effects = vec![];
       transformed_quasis
         .push(quasis_iter.next().unwrap().value.cooked.as_ref().unwrap().to_string());
-      let exprs_len = expressions.len();
-      for (index, expr) in expressions.into_iter().enumerate() {
-        let is_last = index == exprs_len - 1;
-        let expr_span = expr.span();
+      for expr in expressions {
+        let expr = self.transform_expression(expr, true).unwrap();
+        transformed_exprs.push(expr);
+
         let quasi_str = quasis_iter.next().unwrap().value.cooked.as_ref().unwrap().to_string();
-        if let Some(literal) = self.get_folded_literal(AstKind2::Expression(expr)) {
-          if let Some(effect) = self.transform_expression(expr, false) {
-            pending_effects.push(Some(effect));
-          }
-          if !pending_effects.is_empty() && is_last {
-            transformed_exprs.push(build_effect!(
-              &self.ast,
-              expr_span,
-              mem::take(&mut pending_effects);
-              literal.build_expr(self, SPAN, None)
-            ));
-            transformed_quasis.push(quasi_str);
-          } else {
-            let last_quasi = transformed_quasis.pop().unwrap();
-            let expr_str = literal.to_string(self.allocator);
-            transformed_quasis.push(format!("{}{}{}", last_quasi, expr_str, quasi_str));
-          }
-        } else {
-          let expr = self.transform_expression(expr, true).unwrap();
-          transformed_exprs.push(build_effect!(
-            &self.ast,
-            expr_span,
-            mem::take(&mut pending_effects);
-            expr
-          ));
-          transformed_quasis.push(quasi_str);
-        }
+        transformed_quasis.push(quasi_str);
       }
       if transformed_exprs.is_empty() {
         let s = transformed_quasis.pop().unwrap();
-        Some(build_effect!(
-          &self.ast,
-          *span,
-          pending_effects;
-          self.ast.expression_string_literal(*span, self.ast.atom(&s), None)
-        ))
+        Some(self.ast.expression_string_literal(*span, self.ast.atom(&s), None))
       } else {
-        assert!(pending_effects.is_empty());
         let mut quasis = self.ast.vec();
         let quasis_len = transformed_quasis.len();
         for (index, quasi) in transformed_quasis.into_iter().enumerate() {