Add UseCounters for various standards-related code paths

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 15 matching lines @@
 var GlobalDate = global.Date;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 var MakeError;
 var MakeRangeError;
 var MakeTypeError;
 var MathFloor;
 var ObjectDefineProperties = utils.ImportNow("ObjectDefineProperties");
 var ObjectDefineProperty = utils.ImportNow("ObjectDefineProperty");
+var patternSymbol = utils.ImportNow("intl_pattern_symbol");
 var RegExpTest;
+var resolvedSymbol = utils.ImportNow("intl_resolved_symbol");
 var StringIndexOf;
 var StringLastIndexOf;
 var StringMatch;
 var StringReplace;
 var StringSplit;
 var StringSubstr;
 var StringSubstring;
 
 utils.Import(function(from) {
   ArrayIndexOf = from.ArrayIndexOf;
@@ skipping 824 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;
+  }
+};
+
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
     throw MakeTypeError(kReinitializeIntl, "Collator");
   }
 
   if (IS_UNDEFINED(options)) {
@@ skipping 78 matching lines @@
     strength: {writable: true},
     usage: {value: internalOptions.usage, writable: true}
   });
 
   var internalCollator = %CreateCollator(requestedLocale,
                                          internalOptions,
                                          resolved);
 
   // Writable, configurable and enumerable are set to false by default.
   %MarkAsInitializedIntlObjectOfType(collator, 'collator', internalCollator);
-  ObjectDefineProperty(collator, 'resolved', {value: resolved});
+  collator[resolvedSymbol] = resolved;
+  ObjectDefineProperty(collator, 'resolved', resolvedAccessor);
 
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 19 matching lines @@
 %AddNamedProperty(Intl.Collator.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'collator')) {
       throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "Collator");
     }
 
     var coll = this;
-    var locale = getOptimalLanguageTag(coll.resolved.requestedLocale,
-                                       coll.resolved.locale);
+    var locale = getOptimalLanguageTag(coll[resolvedSymbol].requestedLocale,
+                                       coll[resolvedSymbol].locale);
 
     return {
       locale: locale,
-      usage: coll.resolved.usage,
-      sensitivity: coll.resolved.sensitivity,
-      ignorePunctuation: coll.resolved.ignorePunctuation,
-      numeric: coll.resolved.numeric,
-      caseFirst: coll.resolved.caseFirst,
-      collation: coll.resolved.collation
+      usage: coll[resolvedSymbol].usage,
+      sensitivity: coll[resolvedSymbol].sensitivity,
+      ignorePunctuation: coll[resolvedSymbol].ignorePunctuation,
+      numeric: coll[resolvedSymbol].numeric,
+      caseFirst: coll[resolvedSymbol].caseFirst,
+      collation: coll[resolvedSymbol].collation
     };
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.Collator.prototype.resolvedOptions, 'resolvedOptions');
 %FunctionRemovePrototype(Intl.Collator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.Collator.prototype.resolvedOptions);
 
 
 /**
@@ skipping 56 matching lines @@
     value = GlobalNumber(value);
     if (IsNaN(value) || value < min || value > max) {
       throw MakeRangeError(kPropertyValueOutOfRange, property);
     }
     return MathFloor(value);
   }
 
   return fallback;
 }
 
+var patternAccessor = {
+  get() {
+    %IncrementUseCounter(kIntlPattern);
+    return this[patternSymbol];
+  },
+  set(value) {
+    this[patternSymbol] = value;
+  }
+};
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function initializeNumberFormat(numberFormat, locales, options) {
   if (%IsInitializedIntlObject(numberFormat)) {
     throw MakeTypeError(kReinitializeIntl, "NumberFormat");
   }
 
@@ skipping 75 matching lines @@
 
   var requestedLocale = locale.locale + extension;
   var resolved = ObjectDefineProperties({}, {
     currency: {writable: true},
     currencyDisplay: {writable: true},
     locale: {writable: true},
     maximumFractionDigits: {writable: true},
     minimumFractionDigits: {writable: true},
     minimumIntegerDigits: {writable: true},
     numberingSystem: {writable: true},
+    pattern: patternAccessor,
     requestedLocale: {value: requestedLocale, writable: true},
     style: {value: internalOptions.style, writable: true},
     useGrouping: {writable: true}
   });
   if (%HasOwnProperty(internalOptions, 'minimumSignificantDigits')) {
     defineWEProperty(resolved, 'minimumSignificantDigits', UNDEFINED);
   }
   if (%HasOwnProperty(internalOptions, 'maximumSignificantDigits')) {
     defineWEProperty(resolved, 'maximumSignificantDigits', UNDEFINED);
   }
   var formatter = %CreateNumberFormat(requestedLocale,
                                       internalOptions,
                                       resolved);
 
   if (internalOptions.style === 'currency') {
     ObjectDefineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
                                                        writable: true});
   }
 
   %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat', formatter);
-  ObjectDefineProperty(numberFormat, 'resolved', {value: resolved});
+  numberFormat[resolvedSymbol] = resolved;
+  ObjectDefineProperty(numberFormat, 'resolved', resolvedAccessor);
 
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 19 matching lines @@
 %AddNamedProperty(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'numberformat')) {
       throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "NumberFormat");
     }
 
     var format = this;
-    var locale = getOptimalLanguageTag(format.resolved.requestedLocale,
-                                       format.resolved.locale);
+    var locale = getOptimalLanguageTag(format[resolvedSymbol].requestedLocale,
+                                       format[resolvedSymbol].locale);
 
     var result = {
       locale: locale,
-      numberingSystem: format.resolved.numberingSystem,
-      style: format.resolved.style,
-      useGrouping: format.resolved.useGrouping,
-      minimumIntegerDigits: format.resolved.minimumIntegerDigits,
-      minimumFractionDigits: format.resolved.minimumFractionDigits,
-      maximumFractionDigits: format.resolved.maximumFractionDigits,
+      numberingSystem: format[resolvedSymbol].numberingSystem,
+      style: format[resolvedSymbol].style,
+      useGrouping: format[resolvedSymbol].useGrouping,
+      minimumIntegerDigits: format[resolvedSymbol].minimumIntegerDigits,
+      minimumFractionDigits: format[resolvedSymbol].minimumFractionDigits,
+      maximumFractionDigits: format[resolvedSymbol].maximumFractionDigits,
     };
 
     if (result.style === 'currency') {
-      defineWECProperty(result, 'currency', format.resolved.currency);
+      defineWECProperty(result, 'currency', format[resolvedSymbol].currency);
       defineWECProperty(result, 'currencyDisplay',
-                        format.resolved.currencyDisplay);
+                        format[resolvedSymbol].currencyDisplay);
     }
 
-    if (%HasOwnProperty(format.resolved, 'minimumSignificantDigits')) {
+    if (%HasOwnProperty(format[resolvedSymbol], 'minimumSignificantDigits')) {
       defineWECProperty(result, 'minimumSignificantDigits',
-                        format.resolved.minimumSignificantDigits);
+                        format[resolvedSymbol].minimumSignificantDigits);
     }
 
-    if (%HasOwnProperty(format.resolved, 'maximumSignificantDigits')) {
+    if (%HasOwnProperty(format[resolvedSymbol], 'maximumSignificantDigits')) {
       defineWECProperty(result, 'maximumSignificantDigits',
-                        format.resolved.maximumSignificantDigits);
+                        format[resolvedSymbol].maximumSignificantDigits);
     }
 
     return result;
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.NumberFormat.prototype.resolvedOptions,
                  'resolvedOptions');
 %FunctionRemovePrototype(Intl.NumberFormat.prototype.resolvedOptions);
 %SetNativeFlag(Intl.NumberFormat.prototype.resolvedOptions);
@@ skipping 297 matching lines @@
   var resolved = ObjectDefineProperties({}, {
     calendar: {writable: true},
     day: {writable: true},
     era: {writable: true},
     hour12: {writable: true},
     hour: {writable: true},
     locale: {writable: true},
     minute: {writable: true},
     month: {writable: true},
     numberingSystem: {writable: true},
-    pattern: {writable: true},
+    [patternSymbol]: {writable: true},
+    pattern: patternAccessor,
     requestedLocale: {value: requestedLocale, writable: true},
     second: {writable: true},
     timeZone: {writable: true},
     timeZoneName: {writable: true},
     tz: {value: tz, writable: true},
     weekday: {writable: true},
     year: {writable: true}
   });
 
   var formatter = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
   if (resolved.timeZone === "Etc/Unknown") {
     throw MakeRangeError(kUnsupportedTimeZone, tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
-  ObjectDefineProperty(dateFormat, 'resolved', {value: resolved});
+  dateFormat[resolvedSymbol] = resolved;
+  ObjectDefineProperty(dateFormat, 'resolved', resolvedAccessor);
 
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 38 matching lines @@
       'islamic': 'islamic',
       'hebrew': 'hebrew',
       'chinese': 'chinese',
       'indian': 'indian',
       'coptic': 'coptic',
       'ethiopic': 'ethiopic',
       'ethiopic-amete-alem': 'ethioaa'
     };
 
     var format = this;
-    var fromPattern = fromLDMLString(format.resolved.pattern);
-    var userCalendar = ICU_CALENDAR_MAP[format.resolved.calendar];
+    var fromPattern = fromLDMLString(format[resolvedSymbol][patternSymbol]);
+    var userCalendar = ICU_CALENDAR_MAP[format[resolvedSymbol].calendar];
     if (IS_UNDEFINED(userCalendar)) {
       // Use ICU name if we don't have a match. It shouldn't happen, but
       // it would be too strict to throw for this.
-      userCalendar = format.resolved.calendar;
+      userCalendar = format[resolvedSymbol].calendar;
     }
 
-    var locale = getOptimalLanguageTag(format.resolved.requestedLocale,
-                                       format.resolved.locale);
+    var locale = getOptimalLanguageTag(format[resolvedSymbol].requestedLocale,
+                                       format[resolvedSymbol].locale);
 
     var result = {
       locale: locale,
-      numberingSystem: format.resolved.numberingSystem,
+      numberingSystem: format[resolvedSymbol].numberingSystem,
       calendar: userCalendar,
-      timeZone: format.resolved.timeZone
+      timeZone: format[resolvedSymbol].timeZone
     };
 
     addWECPropertyIfDefined(result, 'timeZoneName', fromPattern.timeZoneName);
     addWECPropertyIfDefined(result, 'era', fromPattern.era);
     addWECPropertyIfDefined(result, 'year', fromPattern.year);
     addWECPropertyIfDefined(result, 'month', fromPattern.month);
     addWECPropertyIfDefined(result, 'day', fromPattern.day);
     addWECPropertyIfDefined(result, 'weekday', fromPattern.weekday);
     addWECPropertyIfDefined(result, 'hour12', fromPattern.hour12);
     addWECPropertyIfDefined(result, 'hour', fromPattern.hour);
@@ skipping 131 matching lines @@
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
   var internalIterator = %CreateBreakIterator(locale.locale,
                                               internalOptions,
                                               resolved);
 
   %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator',
                                      internalIterator);
-  ObjectDefineProperty(iterator, 'resolved', {value: resolved});
+  iterator[resolvedSymbol] = resolved;
+  ObjectDefineProperty(iterator, 'resolved', resolvedAccessor);
 
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 20 matching lines @@
   function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'breakiterator')) {
       throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "v8BreakIterator");
     }
 
     var segmenter = this;
-    var locale = getOptimalLanguageTag(segmenter.resolved.requestedLocale,
-                                       segmenter.resolved.locale);
+    var locale =
+        getOptimalLanguageTag(segmenter[resolvedSymbol].requestedLocale,
+                              segmenter[resolvedSymbol].locale);
 
     return {
       locale: locale,
-      type: segmenter.resolved.type
+      type: segmenter[resolvedSymbol].type
     };
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.v8BreakIterator.prototype.resolvedOptions,
                  'resolvedOptions');
 %FunctionRemovePrototype(Intl.v8BreakIterator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.v8BreakIterator.prototype.resolvedOptions);
 
 
@@ skipping 254 matching lines @@
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })