[intl] Fix NumberFormat options handling spec compliance issues

src/js/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ECMAScript 402 API implementation.
 
 /**
  * Intl object is a single object that has some named properties,
  * all of which are constructors.
  */
@@ skipping 14 matching lines @@
 var GlobalIntlNumberFormat = GlobalIntl.NumberFormat;
 var GlobalIntlCollator = GlobalIntl.Collator;
 var GlobalIntlv8BreakIterator = GlobalIntl.v8BreakIterator;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 var IntlFallbackSymbol = utils.ImportNow("intl_fallback_symbol");
 var InstallFunctions = utils.InstallFunctions;
 var InstallGetter = utils.InstallGetter;
 var InternalArray = utils.InternalArray;
+var MaxSimple;
 var ObjectHasOwnProperty = utils.ImportNow("ObjectHasOwnProperty");
 var OverrideFunction = utils.OverrideFunction;
 var patternSymbol = utils.ImportNow("intl_pattern_symbol");
 var resolvedSymbol = utils.ImportNow("intl_resolved_symbol");
 var SetFunctionName = utils.SetFunctionName;
 var StringSubstr = GlobalString.prototype.substr;
 var StringSubstring = GlobalString.prototype.substring;
 
 utils.Import(function(from) {
   ArrayJoin = from.ArrayJoin;
   ArrayPush = from.ArrayPush;
+  MaxSimple = from.MaxSimple;
 });
 
 // Utilities for definitions
 
 function InstallFunction(object, name, func) {
   InstallFunctions(object, DONT_ENUM, [name, func]);
 }
 
 
 /**
@@ skipping 871 matching lines @@
   var language = '(' + alpha + '{2,3}(-' + extLang + ')?|' + alpha + '{4}|' +
                  alpha + '{5,8})';
   var langTag = language + '(-' + script + ')?(-' + region + ')?(-' +
                 variant + ')*(-' + extension + ')*(-' + privateUse + ')?';
 
   var languageTag =
       '^(' + langTag + '|' + privateUse + '|' + grandfathered + ')$';
   LANGUAGE_TAG_RE = new GlobalRegExp(languageTag, 'i');
 }
 
-var resolvedAccessor = {
-  get() {
-    %IncrementUseCounter(kIntlResolved);
-    return this[resolvedSymbol];
-  },
-  set(value) {
-    this[resolvedSymbol] = value;
-  }
-};
-
 // ECMA 402 section 8.2.1
 InstallFunction(GlobalIntl, 'getCanonicalLocales', function(locales) {
     return makeArray(canonicalizeLocaleList(locales));
   }
 );
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
@@ skipping 173 matching lines @@
     value = TO_NUMBER(value);
     if (NUMBER_IS_NAN(value) || value < min || value > max) {
       throw %make_range_error(kPropertyValueOutOfRange, property);
     }
     return %math_floor(value);
   }
 
   return fallback;
 }
 
-
 /**
  * Returns the valid digit count for a property, or throws RangeError on
  * a value out of the range.
  */
 function getNumberOption(options, property, min, max, fallback) {
   var value = options[property];
   return defaultNumberOption(value, min, max, fallback, property);
 }
 
-var patternAccessor = {
-  get() {
-    %IncrementUseCounter(kIntlPattern);
-    return this[patternSymbol];
-  },
-  set(value) {
-    this[patternSymbol] = value;
+// ECMA 402 #sec-setnfdigitoptions
+// SetNumberFormatDigitOptions ( intlObj, options, mnfdDefault, mxfdDefault )
+function SetNumberFormatDigitOptions(internalOptions, options,
+                                     mnfdDefault, mxfdDefault) {
+  // Digit ranges.
+  var mnid = getNumberOption(options, 'minimumIntegerDigits', 1, 21, 1);
+  defineWEProperty(internalOptions, 'minimumIntegerDigits', mnid);
+
+  var mnfd = getNumberOption(options, 'minimumFractionDigits', 0, 20,
+                             mnfdDefault);
+  defineWEProperty(internalOptions, 'minimumFractionDigits', mnfd);
+
+  var mxfdActualDefault = MaxSimple(mnfd, mxfdDefault);
+
+  var mxfd = getNumberOption(options, 'maximumFractionDigits', mnfd, 20,
+                             mxfdActualDefault);
+
+  defineWEProperty(internalOptions, 'maximumFractionDigits', mxfd);
+
+  var mnsd = options['minimumSignificantDigits'];
+  var mxsd = options['maximumSignificantDigits'];
+  if (!IS_UNDEFINED(mnsd) || !IS_UNDEFINED(mxsd)) {
+    mnsd = defaultNumberOption(mnsd, 1, 21, 1, 'minimumSignificantDigits');
+    defineWEProperty(internalOptions, 'minimumSignificantDigits', mnsd);
+
+    mxsd = defaultNumberOption(mxsd, mnsd, 21, 21, 'maximumSignificantDigits');
+    defineWEProperty(internalOptions, 'maximumSignificantDigits', mxsd);
   }
-};
+}
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function CreateNumberFormat(locales, options) {
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'numberformat');
 
   var locale = resolveLocale('numberformat', locales, options);
 
   var internalOptions = {};
   defineWEProperty(internalOptions, 'style', getOption(
     'style', 'string', ['decimal', 'percent', 'currency'], 'decimal'));
 
   var currency = getOption('currency', 'string');
   if (!IS_UNDEFINED(currency) && !isWellFormedCurrencyCode(currency)) {
     throw %make_range_error(kInvalidCurrencyCode, currency);
   }
 
   if (internalOptions.style === 'currency' && IS_UNDEFINED(currency)) {
     throw %make_type_error(kCurrencyCode);
   }
 
+  var mnfdDefault, mxfdDefault;
+
   var currencyDisplay = getOption(
       'currencyDisplay', 'string', ['code', 'symbol', 'name'], 'symbol');
   if (internalOptions.style === 'currency') {
     defineWEProperty(internalOptions, 'currency', %StringToUpperCaseI18N(currency));
     defineWEProperty(internalOptions, 'currencyDisplay', currencyDisplay);
+
+    mnfdDefault = mxfdDefault = %CurrencyDigits(internalOptions.currency);
+  } else {
+    mnfdDefault = 0;
+    mxfdDefault = internalOptions.style === 'percent' ? 0 : 3;
   }
 
-  // Digit ranges.
-  var mnid = getNumberOption(options, 'minimumIntegerDigits', 1, 21, 1);
-  defineWEProperty(internalOptions, 'minimumIntegerDigits', mnid);
-
-  var mnfd = options['minimumFractionDigits'];
-  var mxfd = options['maximumFractionDigits'];
-  if (!IS_UNDEFINED(mnfd) || internalOptions.style !== 'currency') {
-    mnfd = getNumberOption(options, 'minimumFractionDigits', 0, 20, 0);
-    defineWEProperty(internalOptions, 'minimumFractionDigits', mnfd);
-  }
-
-  if (!IS_UNDEFINED(mxfd) || internalOptions.style !== 'currency') {
-    var min_mxfd = internalOptions.style === 'percent' ? 0 : 3;
-    mnfd = IS_UNDEFINED(mnfd) ? 0 : mnfd;
-    var fallback_limit = (mnfd > min_mxfd) ? mnfd : min_mxfd;
-    mxfd = getNumberOption(options, 'maximumFractionDigits', mnfd, 20, fallback_limit);
-    defineWEProperty(internalOptions, 'maximumFractionDigits', mxfd);
-  }
-
-  var mnsd = options['minimumSignificantDigits'];
-  var mxsd = options['maximumSignificantDigits'];
-  if (!IS_UNDEFINED(mnsd) || !IS_UNDEFINED(mxsd)) {
-    mnsd = defaultNumberOption(mnsd, 1, 21, 1, 'minimumSignificantDigits');
-    defineWEProperty(internalOptions, 'minimumSignificantDigits', mnsd);
-
-    mxsd = defaultNumberOption(mxsd, mnsd, 21, 21, 'maximumSignificantDigits');
-    defineWEProperty(internalOptions, 'maximumSignificantDigits', mxsd);
-  }
+  SetNumberFormatDigitOptions(internalOptions, options, mnfdDefault,
+                              mxfdDefault);
 
   // Grouping.
   defineWEProperty(internalOptions, 'useGrouping', getOption(
     'useGrouping', 'boolean', UNDEFINED, true));
 
   // ICU prefers options to be passed using -u- extension key/values for
   // number format, so we need to build that.
   var extensionMap = parseExtension(locale.extension);
 
   /**
@@ skipping 918 matching lines @@
 
 utils.Export(function(to) {
   to.FormatDateToParts = FormatDateToParts;
   to.ToLowerCaseI18N = ToLowerCaseI18N;
   to.ToUpperCaseI18N = ToUpperCaseI18N;
   to.ToLocaleLowerCaseI18N = ToLocaleLowerCaseI18N;
   to.ToLocaleUpperCaseI18N = ToLocaleUpperCaseI18N;
 });
 
 })