fix(es/minifier): Fix optimization of expressions in numeric context (#6965)

Author: magic-akari

crates/swc_ecma_minifier/src/compress/pure/numbers.rs

@@ -1,12 +1,20 @@
 use swc_common::util::take::Take;
 use swc_ecma_ast::*;
+use swc_ecma_utils::num_from_str;
 
 use super::Pure;
 
 impl Pure<'_> {
     pub(super) fn optimize_expr_in_num_ctx(&mut self, e: &mut Expr) {
         if let Expr::Lit(Lit::Str(Str { span, value, .. })) = e {
-            let value = if value.is_empty() { 0f64 } else { 1f64 };
+            let value = if value.is_empty() {
+                0f64
+            } else {
+                match num_from_str(value).into_result() {
+                    Ok(f) if f.is_finite() => f,
+                    _ => return,
+                }
+            };
 
             self.changed = true;
             report_change!("numbers: Converting a string literal to {:?}", value);

crates/swc_ecma_minifier/tests/fixture/issues/6957/number-tostring/output.js

@@ -88,9 +88,9 @@ assertEquals("0", "0");
 assertEquals("100000000000000000000000000000000", "100000000000000000000000000000000");
 assertEquals("100000000000000000000000000000001", "100000000000000000000000000000001");
 assertEquals("100000000000080", "100000000000080");
-assertEquals("1000000000000100", "1");
-assertEquals("1000000000000000", "1");
-assertEquals("1000000000000000", "1");
+assertEquals("1000000000000100", "1000000000000100");
+assertEquals("1000000000000000", "1000000000000000");
+assertEquals("1000000000000000", "1000000000000000");
 assertEquals("100000000000000000000000000000000000000000000000010000000", "100000000000000000000000000000000000000000000000010000000");
 assertEquals("-11111111111111111111111111111111", "-11111111111111111111111111111111");
 assertEquals("-5yc1z", "-5yc1z");

crates/swc_ecma_utils/src/lib.rs

@@ -1575,7 +1575,7 @@ fn may_be_str(ty: Value<Type>) -> bool {
     }
 }
 
-fn num_from_str(s: &str) -> Value<f64> {
+pub fn num_from_str(s: &str) -> Value<f64> {
     if s.contains('\u{000b}') {
         return Unknown;
     }
@@ -1587,11 +1587,28 @@ fn num_from_str(s: &str) -> Value<f64> {
         return Known(0.0);
     }
 
-    if s.starts_with("0x") || s.starts_with("0X") {
-        return match s[2..4].parse() {
-            Ok(n) => Known(n),
-            Err(_) => Known(NAN),
-        };
+    if s.len() >= 2 {
+        match &s.as_bytes()[..2] {
+            b"0x" | b"0X" => {
+                return match u64::from_str_radix(&s[2..], 16) {
+                    Ok(n) => Known(n as f64),
+                    Err(_) => Known(NAN),
+                }
+            }
+            b"0o" | b"0O" => {
+                return match u64::from_str_radix(&s[2..], 8) {
+                    Ok(n) => Known(n as f64),
+                    Err(_) => Known(NAN),
+                };
+            }
+            b"0b" | b"0B" => {
+                return match u64::from_str_radix(&s[2..], 2) {
+                    Ok(n) => Known(n as f64),
+                    Err(_) => Known(NAN),
+                };
+            }
+            _ => {}
+        }
     }
 
     if (s.starts_with('-') || s.starts_with('+'))