Fix #76093: Format strings w/o loss of precision w/ FORMAT_TYPE_DECIMAL

Passing the argument to NumberFormat::format() as a number loses
precision if the value can not be represented precisely as a
double or long integer.  The icu library provides a "decimal number"
type that avoids the loss of prevision when the value is passed
as a string.  Add a new FORMAT_TYPE_DECIMAL to explicitly request
the argument be converted to a string and then passed to icu
that way.

Author: cscott

Zend/zend_API.h

@@ -1526,6 +1526,8 @@ static zend_always_inline zval *zend_try_array_init(zval *zv)
 	_(Z_EXPECTED_ARRAY_OR_STRING_OR_NULL, "of type array|string|null") \
 	_(Z_EXPECTED_STRING_OR_LONG,	"of type string|int") \
 	_(Z_EXPECTED_STRING_OR_LONG_OR_NULL, "of type string|int|null") \
+	_(Z_EXPECTED_STRING_OR_NUMBER,	"of type string|int|float") \
+	_(Z_EXPECTED_STRING_OR_NUMBER_OR_NULL,	"of type string|int|float|null") \
 	_(Z_EXPECTED_OBJECT_OR_CLASS_NAME,	"an object or a valid class name") \
 	_(Z_EXPECTED_OBJECT_OR_CLASS_NAME_OR_NULL, "an object, a valid class name, or null") \
 	_(Z_EXPECTED_OBJECT_OR_STRING,	"of type object|string") \
@@ -2155,6 +2157,17 @@ ZEND_API ZEND_COLD void zend_argument_value_error(uint32_t arg_num, const char *
 #define Z_PARAM_STR_OR_LONG_OR_NULL(dest_str, dest_long, is_null) \
 	Z_PARAM_STR_OR_LONG_EX(dest_str, dest_long, is_null, 1);
 
+#define Z_PARAM_STR_OR_NUMBER_EX(dest, check_null) \
+	Z_PARAM_PROLOGUE(0, 0); \
+	if (UNEXPECTED(!zend_parse_arg_str_or_number(_arg, &dest, check_null, _i))) { \
+		_expected_type = check_null ? Z_EXPECTED_STRING_OR_NUMBER_OR_NULL : Z_EXPECTED_STRING_OR_NUMBER; \
+		_error_code = ZPP_ERROR_WRONG_ARG; \
+		break; \
+	}
+
+#define Z_PARAM_STR_OR_NUMBER(dest) \
+	Z_PARAM_STR_OR_NUMBER_EX(dest, 0)
+
 /* End of new parameter parsing API */
 
 /* Inlined implementations shared by new and old parameter parsing APIs */
@@ -2506,6 +2519,18 @@ static zend_always_inline bool zend_parse_arg_str_or_long(zval *arg, zend_string
 	return 1;
 }
 
+static zend_always_inline bool zend_parse_arg_str_or_number(zval *arg, zval **dest, bool check_null, uint32_t arg_num)
+{
+	if (EXPECTED(Z_TYPE_P(arg) == IS_LONG || Z_TYPE_P(arg) == IS_DOUBLE || Z_TYPE_P(arg) == IS_STRING)) {
+		*dest = arg;
+	} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
+		*dest = NULL;
+	} else {
+		return zend_parse_arg_number_slow(arg, dest, arg_num);
+	}
+	return 1;
+}
+
 static zend_always_inline bool zend_parse_arg_obj_or_class_name(
 	zval *arg, zend_class_entry **destination, bool allow_null
 ) {

ext/intl/formatter/formatter.stub.php

@@ -390,6 +390,11 @@ class NumberFormatter
      * @cvalue FORMAT_TYPE_DOUBLE
      */
     public const TYPE_DOUBLE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue FORMAT_TYPE_DECIMAL
+     */
+    public const TYPE_DECIMAL = UNKNOWN;
     /**
      * @var int
      * @deprecated
@@ -409,7 +414,7 @@ public static function create(string $locale, int $style, ?string $pattern = nul
      * @tentative-return-type
      * @alias numfmt_format
      */
-    public function format(int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false {}
+    public function format(int|float|string $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false {}
 
     /**
      * @param int $offset

ext/intl/formatter/formatter_arginfo.h

@@ -34,11 +34,22 @@ PHP_FUNCTION( numfmt_format )
 	int32_t formatted_len = USIZE(format_buf);
 	FORMATTER_METHOD_INIT_VARS;
 
+	object = getThis();
+
 	/* Parse parameters. */
-	if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "On|l",
-		&object, NumberFormatter_ce_ptr,  &number, &type ) == FAILURE )
-	{
-		RETURN_THROWS();
+	if (object) {
+		ZEND_PARSE_PARAMETERS_START(1, 2)
+			Z_PARAM_STR_OR_NUMBER(number)
+			Z_PARAM_OPTIONAL
+			Z_PARAM_LONG(type)
+		ZEND_PARSE_PARAMETERS_END();
+	} else {
+		ZEND_PARSE_PARAMETERS_START(2, 3)
+			Z_PARAM_OBJECT_OF_CLASS(object, NumberFormatter_ce_ptr)
+			Z_PARAM_STR_OR_NUMBER(number)
+			Z_PARAM_OPTIONAL
+			Z_PARAM_LONG(type)
+		ZEND_PARSE_PARAMETERS_END();
 	}
 
 	/* Fetch the object. */
@@ -53,10 +64,21 @@ PHP_FUNCTION( numfmt_format )
 			case IS_DOUBLE:
 				type = FORMAT_TYPE_DOUBLE;
 				break;
+			case IS_STRING:
+				type = FORMAT_TYPE_DECIMAL;
+				break;
 			EMPTY_SWITCH_DEFAULT_CASE();
 		}
 	}
 
+	// Avoid losing precision on 32-bit platforms where PHP's "long" isn't
+	// as long as the FORMAT_TYPE_INT64 which is requested.
+#if SIZEOF_ZEND_LONG < 8
+	if (Z_TYPE_P(number) == IS_STRING && type == FORMAT_TYPE_INT64) {
+		type = FORMAT_TYPE_DECIMAL;
+	}
+#endif
+
 	switch(type) {
 		case FORMAT_TYPE_INT32:
 			convert_to_long(number);
@@ -76,7 +98,13 @@ PHP_FUNCTION( numfmt_format )
 
 		case FORMAT_TYPE_INT64:
 		{
-			int64_t value = (Z_TYPE_P(number) == IS_DOUBLE)?(int64_t)Z_DVAL_P(number):Z_LVAL_P(number);
+			int64_t value;
+			if (Z_TYPE_P(number) == IS_DOUBLE) {
+				value = (int64_t)Z_DVAL_P(number);
+			} else {
+				convert_to_long(number);
+				value = Z_LVAL_P(number);
+			}
 			formatted_len = unum_formatInt64(FORMATTER_OBJECT(nfo), value, formatted, formatted_len, NULL, &INTL_DATA_ERROR_CODE(nfo));
 			if (INTL_DATA_ERROR_CODE(nfo) == U_BUFFER_OVERFLOW_ERROR) {
 				intl_error_reset(INTL_DATA_ERROR_P(nfo));
@@ -103,6 +131,24 @@ PHP_FUNCTION( numfmt_format )
 			}
 			INTL_METHOD_CHECK_STATUS( nfo, "Number formatting failed" );
 			break;
+
+		case FORMAT_TYPE_DECIMAL:
+			if (!try_convert_to_string(number)) {
+				RETURN_THROWS();
+			}
+			// Convert string as a DecimalNumber, so we don't lose precision
+			formatted_len = unum_formatDecimal(FORMATTER_OBJECT(nfo), Z_STRVAL_P(number), Z_STRLEN_P(number), formatted, formatted_len, NULL, &INTL_DATA_ERROR_CODE(nfo));
+			if (INTL_DATA_ERROR_CODE(nfo) == U_BUFFER_OVERFLOW_ERROR) {
+				intl_error_reset(INTL_DATA_ERROR_P(nfo));
+				formatted = eumalloc(formatted_len);
+				unum_formatDecimal(FORMATTER_OBJECT(nfo), Z_STRVAL_P(number), Z_STRLEN_P(number), formatted, formatted_len, NULL, &INTL_DATA_ERROR_CODE(nfo));
+				if (U_FAILURE( INTL_DATA_ERROR_CODE(nfo) ) ) {
+					efree(formatted);
+				}
+			}
+			INTL_METHOD_CHECK_STATUS( nfo, "Number formatting failed" );
+			break;
+
 		case FORMAT_TYPE_CURRENCY:
 			if (getThis()) {
 				const char *space;
@@ -113,6 +159,7 @@ PHP_FUNCTION( numfmt_format )
 				zend_argument_value_error(3, "cannot be NumberFormatter::TYPE_CURRENCY constant, use numfmt_format_currency() function instead");
 			}
 			RETURN_THROWS();
+
 		default:
 			zend_argument_value_error(getThis() ? 2 : 3, "must be a NumberFormatter::TYPE_* constant");
 			RETURN_THROWS();

ext/intl/formatter/formatter_format.c

@@ -22,5 +22,6 @@
 #define FORMAT_TYPE_INT64	2
 #define FORMAT_TYPE_DOUBLE	3
 #define FORMAT_TYPE_CURRENCY	4
+#define FORMAT_TYPE_DECIMAL	5
 
 #endif // FORMATTER_FORMAT_H

ext/intl/formatter/formatter_format.h

@@ -390,7 +390,7 @@ function datefmt_get_error_message(IntlDateFormatter $formatter): string {}
 
 function numfmt_create(string $locale, int $style, ?string $pattern = null): ?NumberFormatter {}
 
-function numfmt_format(NumberFormatter $formatter, int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false {}
+function numfmt_format(NumberFormatter $formatter, int|float|string $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false {}
 
 /** @param int $offset */
 function numfmt_parse(NumberFormatter $formatter, string $string, int $type = NumberFormatter::TYPE_DOUBLE, &$offset = null): int|float|false {}

ext/intl/php_intl.stub.php

@@ -5,20 +5,50 @@ intl
 --FILE--
 <?php
 
+$testcases = ['', 1, NULL, true, false, [], (object)[]];
+
+echo("OOP\n");
 $x = new NumberFormatter('en_US', NumberFormatter::DECIMAL);
-foreach (['', 1, NULL, $x] as $value) {
+foreach (array_merge($testcases, [$x]) as $value) {
     try {
         var_dump($x->format($value));
     } catch (TypeError $ex) {
         echo $ex->getMessage(), PHP_EOL;
     }
 }
 
+echo("\nNon-OOP\n");
+$x = numfmt_create('en_US', NumberFormatter::DECIMAL);
+foreach (array_merge($testcases, [$x]) as $value) {
+    try {
+        var_dump(numfmt_format($x, $value));
+    } catch (TypeError $ex) {
+        echo $ex->getMessage(), PHP_EOL;
+    }
+}
+
 ?>
 --EXPECTF--
-NumberFormatter::format(): Argument #1 ($num) must be of type int|float, string given
+OOP
+bool(false)
 string(1) "1"
 
-Deprecated: NumberFormatter::format(): Passing null to parameter #1 ($num) of type int|float is deprecated in %s on line %d
+Deprecated: NumberFormatter::format(): Passing null to parameter #1 ($num) of type string|int|float is deprecated in %s on line %d
+string(1) "0"
+string(1) "1"
+string(1) "0"
+NumberFormatter::format(): Argument #1 ($num) must be of type string|int|float, array given
+NumberFormatter::format(): Argument #1 ($num) must be of type string|int|float, stdClass given
+NumberFormatter::format(): Argument #1 ($num) must be of type string|int|float, NumberFormatter given
+
+Non-OOP
+bool(false)
+string(1) "1"
+
+Deprecated: numfmt_format(): Passing null to parameter #2 ($num) of type string|int|float is deprecated in %s on line %d
+string(1) "0"
+string(1) "1"
 string(1) "0"
-NumberFormatter::format(): Argument #1 ($num) must be of type int|float, NumberFormatter given
+numfmt_format(): Argument #2 ($num) must be of type string|int|float, array given
+numfmt_format(): Argument #2 ($num) must be of type string|int|float, stdClass given
+numfmt_format(): Argument #2 ($num) must be of type string|int|float, NumberFormatter given

ext/intl/php_intl_arginfo.h

@@ -0,0 +1,71 @@
+--TEST--
+Bug #76093 (NumberFormatter::format loses precision)
+--SKIPIF--
+<?php if( !extension_loaded( 'intl' ) ) print 'skip'; ?>
+--FILE--
+<?php
+
+# See also https://phabricator.wikimedia.org/T268456
+$x = new NumberFormatter('en_US', NumberFormatter::DECIMAL);
+foreach ([
+    '999999999999999999', # Fits in signed 64-bit integer
+    '9999999999999999999', # Does not fit in signed 64-bit integer
+    9999999999999999999, # Precision loss seen when passing as number
+    ] as $value) {
+    try {
+        var_dump([
+            'input' => $value,
+            'default' => $x->format($value),
+            # Note that TYPE_INT64 isn't actually guaranteed to have an
+            # 64-bit integer as input, because PHP on 32-bit platforms only
+            # has 32-bit integers.  If you pass the value as a string, PHP
+            # will use the TYPE_DECIMAL type in order to extend the range.
+            # Also, casting from double to int64 when the int64 range
+            # is exceeded results in an implementation-defined value.
+            'int64' => $x->format($value, NumberFormatter::TYPE_INT64),
+            'double' => $x->format($value, NumberFormatter::TYPE_DOUBLE),
+            'decimal' => $x->format($value, NumberFormatter::TYPE_DECIMAL),
+        ]);
+    } catch (TypeError $ex) {
+        echo $ex->getMessage(), PHP_EOL;
+    }
+}
+
+?>
+--EXPECTF--
+array(5) {
+  ["input"]=>
+  string(18) "999999999999999999"
+  ["default"]=>
+  string(23) "999,999,999,999,999,999"
+  ["int64"]=>
+  string(23) "999,999,999,999,999,999"
+  ["double"]=>
+  string(25) "1,000,000,000,000,000,000"
+  ["decimal"]=>
+  string(23) "999,999,999,999,999,999"
+}
+array(5) {
+  ["input"]=>
+  string(19) "9999999999999999999"
+  ["default"]=>
+  string(25) "9,999,999,999,999,999,999"
+  ["int64"]=>
+  string(%d) "%r9,223,372,036,854,775,807|9,999,999,999,999,999,999%r"
+  ["double"]=>
+  string(26) "10,000,000,000,000,000,000"
+  ["decimal"]=>
+  string(25) "9,999,999,999,999,999,999"
+}
+array(5) {
+  ["input"]=>
+  float(1.0E+19)
+  ["default"]=>
+  string(26) "10,000,000,000,000,000,000"
+  ["int64"]=>
+  string(%d) "%r[+-]?[0-9,]+%r"
+  ["double"]=>
+  string(26) "10,000,000,000,000,000,000"
+  ["decimal"]=>
+  string(26) "10,000,000,000,000,000,000"
+}