[es6] Map/Set size getter should have "get size" name

src/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 236 matching lines @@
           // DateTimeFormat.format needs to be 0 arg method, but can stil
           // receive optional dateValue param. If one was provided, pass it
           // along.
           if (%_ArgumentsLength() > 0) {
             return implementation(that, %_Arguments(0));
           } else {
             return implementation(that);
           }
         }
       }
-      %FunctionSetName(boundMethod, internalName);
+      SetFunctionName(boundMethod, internalName);
       %FunctionRemovePrototype(boundMethod);
       %SetNativeFlag(boundMethod);
       this[internalName] = boundMethod;
     }
     return this[internalName];
   }
 
-  %FunctionSetName(getter, methodName);
+  SetFunctionName(getter, methodName);
   %FunctionRemovePrototype(getter);
   %SetNativeFlag(getter);
 
   ObjectDefineProperty(obj.prototype, methodName, {
     get: getter,
     enumerable: false,
     configurable: true
   });
 }
 
@@ skipping 707 matching lines @@
       usage: coll.resolved.usage,
       sensitivity: coll.resolved.sensitivity,
       ignorePunctuation: coll.resolved.ignorePunctuation,
       numeric: coll.resolved.numeric,
       caseFirst: coll.resolved.caseFirst,
       collation: coll.resolved.collation
     };
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.Collator.prototype.resolvedOptions, 'resolvedOptions');
+SetFunctionName(Intl.Collator.prototype.resolvedOptions, 'resolvedOptions');
 %FunctionRemovePrototype(Intl.Collator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.Collator.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.Collator, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('collator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.Collator.supportedLocalesOf, 'supportedLocalesOf');
+SetFunctionName(Intl.Collator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.Collator.supportedLocalesOf);
 %SetNativeFlag(Intl.Collator.supportedLocalesOf);
 
 
 /**
  * When the compare method is called with two arguments x and y, it returns a
  * Number other than NaN that represents the result of a locale-sensitive
  * String comparison of x with y.
  * The result is intended to order String values in the sort order specified
  * by the effective locale and collation options computed during construction
@@ skipping 203 matching lines @@
 
     if (format.resolved.hasOwnProperty('maximumSignificantDigits')) {
       defineWECProperty(result, 'maximumSignificantDigits',
                         format.resolved.maximumSignificantDigits);
     }
 
     return result;
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.NumberFormat.prototype.resolvedOptions,
+SetFunctionName(Intl.NumberFormat.prototype.resolvedOptions,
                  'resolvedOptions');
 %FunctionRemovePrototype(Intl.NumberFormat.prototype.resolvedOptions);
 %SetNativeFlag(Intl.NumberFormat.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.NumberFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('numberformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.NumberFormat.supportedLocalesOf, 'supportedLocalesOf');
+SetFunctionName(Intl.NumberFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.NumberFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.NumberFormat.supportedLocalesOf);
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(value)
  * according to the effective locale and the formatting options of this
  * NumberFormat.
  */
 function formatNumber(formatter, value) {
@@ skipping 350 matching lines @@
     addWECPropertyIfDefined(result, 'weekday', fromPattern.weekday);
     addWECPropertyIfDefined(result, 'hour12', fromPattern.hour12);
     addWECPropertyIfDefined(result, 'hour', fromPattern.hour);
     addWECPropertyIfDefined(result, 'minute', fromPattern.minute);
     addWECPropertyIfDefined(result, 'second', fromPattern.second);
 
     return result;
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.DateTimeFormat.prototype.resolvedOptions,
-                 'resolvedOptions');
+SetFunctionName(Intl.DateTimeFormat.prototype.resolvedOptions,
+                'resolvedOptions');
 %FunctionRemovePrototype(Intl.DateTimeFormat.prototype.resolvedOptions);
 %SetNativeFlag(Intl.DateTimeFormat.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.DateTimeFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('dateformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.DateTimeFormat.supportedLocalesOf, 'supportedLocalesOf');
+SetFunctionName(Intl.DateTimeFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.DateTimeFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.DateTimeFormat.supportedLocalesOf);
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(date)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
  */
 function formatDate(formatter, dateValue) {
@@ skipping 137 matching lines @@
     var locale = getOptimalLanguageTag(segmenter.resolved.requestedLocale,
                                        segmenter.resolved.locale);
 
     return {
       locale: locale,
       type: segmenter.resolved.type
     };
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.v8BreakIterator.prototype.resolvedOptions,
-                 'resolvedOptions');
+SetFunctionName(Intl.v8BreakIterator.prototype.resolvedOptions,
+                'resolvedOptions');
 %FunctionRemovePrototype(Intl.v8BreakIterator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.v8BreakIterator.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.v8BreakIterator, 'supportedLocalesOf',
   function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('breakiterator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-%FunctionSetName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
+SetFunctionName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.v8BreakIterator.supportedLocalesOf);
 %SetNativeFlag(Intl.v8BreakIterator.supportedLocalesOf);
 
 
 /**
  * Adopts text to segment using the iterator. Old text, if present,
  * gets discarded.
  */
 function adoptText(iterator, text) {
   %BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(iterator),
@@ skipping 212 matching lines @@
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })();