Update NumberFormat to treat -0 as a negative number and PluralRules to not define sigfig properties on the resolved options if the user did not request them

Author: jackhorton

lib/Runtime/Library/InJavascript/Intl.js

@@ -929,14 +929,18 @@
      *
      * @param {String[]} props The list of properties to extract from hiddenObject and add to the final resolved options
      * @param {Object} hiddenObject The hiddenObject of the calling constructor that contains values for each prop in props
-     * @param {Function} func An optional custom function(prop, resolved) run for each prop; if omitted, default logic will be used
+     * @param {Function} func An optional custom function(prop, resolved) run for each prop; it should return true when
+     * it handles a property itself. If it does not return true, the default logic will be used.
      */
     const createResolvedOptions = function (props, hiddenObject, func = null) {
         const resolved = _.create();
         _.forEach(props, function (prop) {
-            if (func !== null) {
-                func(prop, resolved);
-            } else if (typeof hiddenObject[prop] !== "undefined") {
+            if (func !== null && func(prop, resolved) === true) {
+                // the callback returned true, which means this property was handled and we can go to the next one
+                return;
+            }
+
+            if (typeof hiddenObject[prop] !== "undefined") {
                 resolved[prop] = hiddenObject[prop];
             }
         });
@@ -1220,8 +1224,7 @@
             InitializeNumberFormat(stateObject, arguments[0], arguments[1]);
 
             const n = Internal.ToNumber(this);
-            // Need to special case the "-0" case to format as 0 instead of -0.
-            return platform.formatNumber(n === -0 ? 0 : n, stateObject, /* toParts */ false, /* forNumberPrototypeToLocaleString */ true);
+            return platform.formatNumber(n, stateObject, /* toParts */ false, /* forNumberPrototypeToLocaleString */ true);
         }), IntlBuiltInFunctionID.NumberToLocaleString);
 
         if (InitType === "Number") {
@@ -1266,8 +1269,7 @@
                 platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
             }
 
-            // Need to special case the '-0' case to format as 0 instead of -0.
-            return platform.formatNumber(n === -0 ? 0 : n, hiddenObject, /* toParts */ false, /* forNumberPrototypeToLocaleString */ false);
+            return platform.formatNumber(n, hiddenObject, /* toParts */ false, /* forNumberPrototypeToLocaleString */ false);
         });
 
         const formatToParts = tagPublicFunction("Intl.NumberFormat.prototype.formatToParts", function formatToParts(n) {
@@ -1282,8 +1284,7 @@
                 platform.raiseNeedObjectOfType("NumberFormat.prototype.formatToParts", "NumberFormat");
             }
 
-            // Need to special case the '-0' case to format as 0 instead of -0.
-            return platform.formatNumber(n === -0 ? 0 : n, hiddenObject, /* toParts */ true, /* forNumberPrototypeToLocaleString */ false);
+            return platform.formatNumber(n, hiddenObject, /* toParts */ true, /* forNumberPrototypeToLocaleString */ false);
         });
 
         // See explanation of `getCanonicalLocales`
@@ -1933,8 +1934,8 @@
                             resolved.hourCycle = hc;
                             resolved.hour12 = hc === "h11" || hc === "h12";
                         }
-                    } else if (hiddenObject[prop] !== undefined && hiddenObject[prop] !== null) {
-                        resolved[prop] = hiddenObject[prop];
+
+                        return true;
                     }
                 });
             },
@@ -2096,8 +2097,7 @@
                 if (prop === "pluralCategories") {
                     // https://github.com/tc39/ecma402/issues/224: create a copy of the pluralCategories array
                     resolved.pluralCategories = _.slice(pr.pluralCategories, 0);
-                } else {
-                    resolved[prop] = pr[prop];
+                    return true;
                 }
             });
         };
@@ -3181,8 +3181,7 @@
                 InitializeNumberFormat(stateObject, arguments[0], arguments[1]);
 
                 var n = Internal.ToNumber(this);
-                // Need to special case the '-0' case to format as 0 instead of -0.
-                return String(platform.formatNumber(n === -0 ? 0 : n, stateObject));
+                return String(platform.formatNumber(n, stateObject));
             }), IntlBuiltInFunctionID.NumberToLocaleString);
 
             if (InitType === 'Intl') {
@@ -3226,8 +3225,7 @@
                         platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
                     }
 
-                    // Need to special case the '-0' case to format as 0 instead of -0.
-                    return String(platform.formatNumber(n === -0 ? 0 : n, hiddenObject));
+                    return String(platform.formatNumber(n, hiddenObject));
                 }
                 tagPublicFunction("Intl.NumberFormat.prototype.format", format);
 

test/Intl/NumberFormat.js

@@ -155,15 +155,19 @@ const tests = [
         }
     },
     {
-        name: "Negative 0",
+        name: "Negative 0 (https://github.com/tc39/ecma402/issues/219)",
         body() {
             assert.areEqual(
                 0,
                 new Intl.NumberFormat(undefined, { minimumFractionDigits: -0 }).resolvedOptions().minimumFractionDigits,
                 "Passing -0 for minimumFractionDigits should get normalized to 0 by DefaultNumberOption"
             );
-            // This assert may need to change in the future, pending any decision made on https://github.com/tc39/ecma402/issues/219
-            assert.areEqual("0", (-0).toLocaleString(), "-0 should be formatted as 0");
+
+            assert.areEqual("-0", (-0).toLocaleString(), "-0 should be treated as a negative number (toLocaleString)");
+            assert.areEqual("-0", new Intl.NumberFormat().format(-0), "-0 should be treated as a negative number (NumberFormat.prototype.format)");
+            if (WScript.Platform.INTL_LIBRARY === "icu") {
+                assert.areEqual("-0", new Intl.NumberFormat().formatToParts(-0).map(v => v.value).join(""), "-0 should be treated as a negative number (NumberFormat.prototype.formatToParts)");
+            }
         }
     },
     {

test/Intl/PluralRules.js

@@ -115,12 +115,26 @@ testRunner.runTests([
         body() {
             function test(options, n, expected) {
                 const pr = new Intl.PluralRules("en", options);
+                const res = pr.resolvedOptions();
                 assert.areEqual(expected, pr.select(n), `Incorrect result using n = ${n} and options = ${JSON.stringify(options)}`);
+
+                // We should only report sigfigs in the resolved options if they were asked for https://github.com/tc39/ecma402/issues/244
+                if (options.minimumSignificantDigits !== undefined || options.maximumSignificantDigits !== undefined) {
+                    if (options.minimumSignificantDigits !== undefined) {
+                        assert.areEqual(options.minimumSignificantDigits, res.minimumSignificantDigits, "Incorrect minimumSignificantDigits");
+                    }
+                    if (options.maximumSignificantDigits !== undefined) {
+                        assert.areEqual(options.maximumSignificantDigits, res.maximumSignificantDigits, "Incorrect maximumSignificantDigits");
+                    }
+                } else {
+                    assert.isFalse(res.hasOwnProperty("minimumSignificantDigits"), "Reported minimumSignificantDigits when it shouldn't have been");
+                    assert.isFalse(res.hasOwnProperty("maximumSignificantDigits"), "Reported maximumSignificantDigits when it shouldn't have been");
+                }
             }
 
-            test(undefined, 1.0, "one");
-            test(undefined, 1.1, "other");
-            test(undefined, 1.001, "other");
+            test({}, 1.0, "one");
+            test({}, 1.1, "other");
+            test({}, 1.001, "other");
 
             test({ minimumFractionDigits: 1 }, 1.0, "one");
             test({ minimumFractionDigits: 1 }, 1.1, "other");
@@ -145,6 +159,9 @@ testRunner.runTests([
             test({ maximumSignificantDigits: 1 }, 1.0, "one");
             test({ maximumSignificantDigits: 1 }, 1.1, "one");
             test({ maximumSignificantDigits: 1 }, 1.001, "one");
+
+            // significantDigits should override fractionDigits and integerDigits
+            test({ maximumSignificantDigits: 2, maximumFractionDigits: 0 }, 1.1, "other");
         }
     },
 ], { verbose: false });