fix(es/minifier): apply ToUint16 in fromCharCode (#12055)

**Description:**

`String.fromCharCode` applies ECMAScript `ToUint16` to every argument.
The current floor-and-cast folding path does not match that behavior for
negative, wrapping, or non-finite inputs.

This PR adds `JsNumber::to_uint16` and uses it before folding ASCII
`String.fromCharCode` results. Boundary coverage keeps the optimization
limited to values whose output can be produced safely.

**Related issue (if exists):**

- #12043
  - #12047
    - #12050
      - #12048
        - #12051
      - #12052
        - #12053
      - #12054
      - **#12055** (current)
      - #12056
      - #12057
    - #12058
    - #12049
      - #12059
        - #12060

Author: magic-akari

.changeset/fix-string-from-char-code-uint16.md

@@ -0,0 +1,7 @@
+---
+swc_core: minor
+swc_ecma_minifier: patch
+swc_ecma_utils: minor
+---
+
+fix(es/minifier): Apply `ToUint16` when folding `String.fromCharCode`.

crates/swc_ecma_minifier/src/compress/optimize/evaluate.rs

@@ -3,7 +3,7 @@ use std::num::FpCategory;
 use swc_atoms::atom;
 use swc_common::{util::take::Take, Spanned, SyntaxContext, DUMMY_SP};
 use swc_ecma_ast::*;
-use swc_ecma_utils::{ExprExt, Value::Known};
+use swc_ecma_utils::{number::JsNumber, ExprExt, Value::Known};
 
 use super::{BitCtx, Optimizer};
 use crate::{
@@ -334,15 +334,15 @@ impl Optimizer<'_> {
                         }
 
                         if let Known(char_code) = args[0].expr.as_pure_number(self.ctx.expr_ctx) {
-                            let v = char_code.floor() as u32;
+                            let v = u32::from(JsNumber::from(char_code).to_uint16());
 
                             if let Some(v) = char::from_u32(v) {
                                 if !v.is_ascii() {
                                     return;
                                 }
                                 self.changed = true;
                                 report_change!(
-                                    "evaluate: Evaluated `String.charCodeAt({})` as `{}`",
+                                    "evaluate: Evaluated `String.fromCharCode({})` as `{}`",
                                     char_code,
                                     v
                                 );

crates/swc_ecma_minifier/tests/fixture/issues/string-from-char-code-uint16/config.json

@@ -0,0 +1,4 @@
+{
+    "defaults": true,
+    "passes": 2
+}

crates/swc_ecma_minifier/tests/fixture/issues/string-from-char-code-uint16/expected.stdout

@@ -0,0 +1 @@
+65,65535,1,0,1,0,0,0,65,65

crates/swc_ecma_minifier/tests/fixture/issues/string-from-char-code-uint16/input.js

@@ -0,0 +1,12 @@
+console.log([
+    String.fromCharCode(65.9),
+    String.fromCharCode(-1),
+    String.fromCharCode(-65535.9),
+    String.fromCharCode(65536),
+    String.fromCharCode(65537),
+    String.fromCharCode(NaN),
+    String.fromCharCode(Infinity),
+    String.fromCharCode(-Infinity),
+    String.fromCharCode(4294967361),
+    String.fromCharCode(-4294967231),
+].map((value) => value.charCodeAt(0)).join(","));

crates/swc_ecma_minifier/tests/fixture/issues/string-from-char-code-uint16/output.js

@@ -0,0 +1,12 @@
+console.log([
+    "A",
+    String.fromCharCode(-1),
+    "\x01",
+    "\0",
+    "\x01",
+    "\0",
+    String.fromCharCode(1 / 0),
+    String.fromCharCode(-1 / 0),
+    "A",
+    "A"
+].map((value)=>value.charCodeAt(0)).join(","));

crates/swc_ecma_utils/src/number.rs

@@ -53,6 +53,13 @@ impl std::ops::Deref for JsNumber {
 }
 
 impl JsNumber {
+    /// Applies ECMAScript `ToUint16` conversion.
+    ///
+    /// <https://tc39.es/ecma262/#sec-touint16>
+    pub fn to_uint16(self) -> u16 {
+        self.as_uint32() as u16
+    }
+
     // https://tc39.es/ecma262/#sec-toint32
     fn as_int32(&self) -> i32 {
         self.as_uint32() as i32
@@ -313,6 +320,20 @@ mod test_js_number {
         assert_eq!(JsNumber(-8.0).as_uint32(), 4294967288);
     }
 
+    #[test]
+    fn test_to_uint16() {
+        assert_eq!(JsNumber(65.9).to_uint16(), 65);
+        assert_eq!(JsNumber(-1.0).to_uint16(), 65535);
+        assert_eq!(JsNumber(-65535.9).to_uint16(), 1);
+        assert_eq!(JsNumber(65536.0).to_uint16(), 0);
+        assert_eq!(JsNumber(65537.0).to_uint16(), 1);
+        assert_eq!(JsNumber(f64::NAN).to_uint16(), 0);
+        assert_eq!(JsNumber(f64::INFINITY).to_uint16(), 0);
+        assert_eq!(JsNumber(f64::NEG_INFINITY).to_uint16(), 0);
+        assert_eq!(JsNumber(4294967361.0).to_uint16(), 65);
+        assert_eq!(JsNumber(-4294967231.0).to_uint16(), 65);
+    }
+
     #[test]
     fn test_add() {
         assert_eq!(JsNumber(1.0) + JsNumber(2.0), JsNumber(3.0));