feat(minifier): implement Number known methods (#12078)

My vacation is near, so I may have some time resuming my contributions.
Here it is just implementing some functionalities that may never be used
in actual usage :-)

I'm not sure if the minsize result is accurate, since there may be a
problem with my `minsize` locally. I'll check my local `minsize` later,
and I'll use the CI as a test this time.

---------

Co-authored-by: Boshen <boshenc@gmail.com>

Author: 7086cmd

crates/oxc_minifier/src/peephole/replace_known_methods.rs

@@ -73,6 +73,9 @@ impl<'a> PeepholeOptimizations {
             "fromCharCode" => Self::try_fold_string_from_char_code(*span, arguments, object, ctx),
             "toString" => Self::try_fold_to_string(*span, arguments, object, ctx),
             "pow" => self.try_fold_pow(*span, arguments, object, ctx),
+            "isFinite" | "isNaN" | "isInteger" | "isSafeInteger" => {
+                Self::try_fold_number_methods(*span, arguments, object, name, ctx)
+            }
             "sqrt" | "cbrt" => Self::try_fold_roots(*span, arguments, name, object, ctx),
             "abs" | "ceil" | "floor" | "round" | "fround" | "trunc" | "sign" => {
                 Self::try_fold_math_unary(*span, arguments, name, object, ctx)
@@ -1025,6 +1028,38 @@ impl<'a> PeepholeOptimizations {
             _ => None,
         }
     }
+
+    fn try_fold_number_methods(
+        span: Span,
+        args: &mut Arguments<'a>,
+        object: &Expression<'a>,
+        name: &str,
+        ctx: &mut Ctx<'a, '_>,
+    ) -> Option<Expression<'a>> {
+        if !Self::validate_global_reference(object, "Number", ctx) {
+            return None;
+        }
+        if args.len() != 1 {
+            return None;
+        }
+        let extracted_expr = args.first()?.as_expression()?;
+        if !extracted_expr.is_number_literal() {
+            return None;
+        }
+        let extracted = extracted_expr.get_side_free_number_value(ctx)?;
+        let result = match name {
+            "isFinite" => Some(extracted.is_finite()),
+            "isInteger" => Some(extracted.fract().abs() < f64::EPSILON),
+            "isNaN" => Some(extracted.is_nan()),
+            "isSafeInteger" => {
+                let integer = extracted.fract().abs() < f64::EPSILON;
+                let safe = extracted.abs() <= 2f64.powi(53) - 1.0;
+                Some(safe && integer)
+            }
+            _ => None,
+        };
+        result.map(|value| ctx.ast.expression_boolean_literal(span, value))
+    }
 }
 
 /// Port from: <https://github.com/google/closure-compiler/blob/v20240609/test/com/google/javascript/jscomp/PeepholeReplaceKnownMethodsTest.java>
@@ -1650,36 +1685,33 @@ mod test {
     }
 
     #[test]
-    #[ignore]
     fn test_fold_number_functions_is_safe_integer() {
-        test("Number.isSafeInteger(1)", "true");
-        test("Number.isSafeInteger(1.5)", "false");
-        test("Number.isSafeInteger(9007199254740991)", "true");
-        test("Number.isSafeInteger(9007199254740992)", "false");
-        test("Number.isSafeInteger(-9007199254740991)", "true");
-        test("Number.isSafeInteger(-9007199254740992)", "false");
+        test_value("Number.isSafeInteger(1)", "!0");
+        test_value("Number.isSafeInteger(1.5)", "!1");
+        test_value("Number.isSafeInteger(9007199254740991)", "!0");
+        test_value("Number.isSafeInteger(9007199254740992)", "!1");
+        test_value("Number.isSafeInteger(-9007199254740991)", "!0");
+        test_value("Number.isSafeInteger(-9007199254740992)", "!1");
     }
 
     #[test]
-    #[ignore]
     fn test_fold_number_functions_is_finite() {
-        test("Number.isFinite(1)", "true");
-        test("Number.isFinite(1.5)", "true");
-        test("Number.isFinite(NaN)", "false");
-        test("Number.isFinite(Infinity)", "false");
-        test("Number.isFinite(-Infinity)", "false");
-        test_same("Number.isFinite('a')");
+        test_value("Number.isFinite(1)", "!0");
+        test_value("Number.isFinite(1.5)", "!0");
+        test_value("Number.isFinite(NaN)", "!1");
+        test_value("Number.isFinite(Infinity)", "!1");
+        test_value("Number.isFinite(-Infinity)", "!1");
+        test_same_value("Number.isFinite('a')");
     }
 
     #[test]
-    #[ignore]
     fn test_fold_number_functions_is_nan() {
-        test("Number.isNaN(1)", "false");
-        test("Number.isNaN(1.5)", "false");
-        test("Number.isNaN(NaN)", "true");
-        test_same("Number.isNaN('a')");
+        test_value("Number.isNaN(1)", "!1");
+        test_value("Number.isNaN(1.5)", "!1");
+        test_value("Number.isNaN(NaN)", "!0");
+        test_same_value("Number.isNaN('a')");
         // unknown function may have side effects
-        test_same("Number.isNaN(+(void unknown()))");
+        test_same_value("Number.isNaN(+(void unknown()))");
     }
 
     #[test]