ffi: combine fast integer validation and conversion

Validate and convert integer arguments in a single helper to avoid
repeated type metadata lookups and conversion checks.

Handle safe integer Number inputs for 64-bit arguments separately,
while preserving the existing type and range checks for BigInt inputs.
Return other argument types unchanged for subsequent pointer conversion.

Signed-off-by: HoonDongKang <d159123@naver.com>
Assisted-by: Codex:Astra-medium

Author: HoonDongKang

lib/internal/ffi/fast-api.js

@@ -85,34 +85,24 @@ function throwFFIArgCountError(expected, actual) {
     `Invalid argument count: expected ${expected}, got ${actual}`);
 }
 
-function validateFastIntegerArg(type, value, index) {
+function validateAndConvertFastIntegerArg(type, value, index) {
   const info = fastIntegerTypeInfo[type];
-  if (info === undefined) return;
+  if (info === undefined) return value;
 
-  let valid;
-
-  if (info.kind === 'number') {
-    valid = typeof value === 'number' && NumberIsInteger(value) &&
-            value >= info.min && value <= info.max;
-  } else if (typeof value === 'bigint') {
-    valid = value >= info.min && value <= info.max;
-  } else {
-    valid = typeof value === 'number' && NumberIsSafeInteger(value) &&
-            (info.min < 0n || value >= 0);
+  // The native Fast API expects BigInt for 64-bit integer arguments.
+  if (info.kind === 'bigint' && typeof value === 'number') {
+    if (!NumberIsSafeInteger(value) || (info.min === 0n && value < 0)) {
+      throwFFIArgError(`Argument ${index} must be ${info.label}`);
+    }
+    return BigInt(value);
   }
 
-  if (!valid) {
+  const validType = info.kind === 'number' ?
+    typeof value === 'number' && NumberIsInteger(value) :
+    typeof value === 'bigint';
+  if (!validType || value < info.min || value > info.max) {
     throwFFIArgError(`Argument ${index} must be ${info.label}`);
   }
-}
-
-function convertFastIntegerArg(type, value) {
-  const info = fastIntegerTypeInfo[type];
-  if (info !== undefined &&
-      info.kind === 'bigint' &&
-      typeof value === 'number') {
-    return BigInt(value);
-  }
 
   return value;
 }
@@ -246,8 +236,7 @@ function getFastArgumentIndexes(argumentsTypes) {
 }
 
 function convertFastArg(type, value, stringState, index) {
-  validateFastIntegerArg(type, value, index);
-  value = convertFastIntegerArg(type, value);
+  value = validateAndConvertFastIntegerArg(type, value, index);
 
   return needsPointerConversion(type) ?
     convertPointerArg(type, value, stringState, index) : value;
@@ -320,9 +309,8 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
       if (arguments.length !== 1) {
         throwFFIArgCountError(1, arguments.length);
       }
-      validateFastIntegerArg(t0, a0, 0);
+      let arg = validateAndConvertFastIntegerArg(t0, a0, 0);
       validateFastPointerArg(t0, a0, 0);
-      let arg = convertFastIntegerArg(t0, a0);
       if (needsNullPointerConversion(t0) &&
           (arg === null || arg === undefined)) {
         arg = 0n;