Bugfix: internationalization routines fail on monkeypatching.

src/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 263 matching lines @@
       %SetNativeFlag(boundMethod);
       this[internalName] = boundMethod;
     }
     return this[internalName];
   }
 
   %FunctionSetName(getter, methodName);
   %FunctionRemovePrototype(getter);
   %SetNativeFlag(getter);
 
-  $Object.defineProperty(obj.prototype, methodName, {
+  ObjectDefineProperty(obj.prototype, methodName, {
     get: getter,
     enumerable: false,
     configurable: true
   });
 }
 
 
 /**
  * Returns an intersection of locales and service supported locales.
  * Parameter locales is treated as a priority list.
@@ skipping 314 matching lines @@
   return extension === ''? '' : '-u' + extension;
 }
 
 
 /**
  * Converts all OwnProperties into
  * configurable: false, writable: false, enumerable: true.
  */
 function freezeArray(array) {
   array.forEach(function(element, index) {
-    $Object.defineProperty(array, index, {value: element,
+    ObjectDefineProperty(array, index, {value: element,
                                           configurable: false,
                                           writable: false,
                                           enumerable: true});
   });
 
-  $Object.defineProperty(array, 'length', {value: array.length,
-                                           writable: false});
-
+  ObjectDefineProperty(array, 'length', {value: array.length,
+                                         writable: false});
   return array;
 }
 
 
 /**
  * It's sometimes desireable to leave user requested locale instead of ICU
  * supported one (zh-TW is equivalent to zh-Hant-TW, so we should keep shorter
  * one, if that was what user requested).
  * This function returns user specified tag if its maximized form matches ICU
  * resolved locale. If not we return ICU result.
@@ skipping 40 matching lines @@
 
   return available;
 }
 
 
 /**
  * Defines a property and sets writable and enumerable to true.
  * Configurable is false by default.
  */
 function defineWEProperty(object, property, value) {
-  $Object.defineProperty(object, property,
-                         {value: value, writable: true, enumerable: true});
+  ObjectDefineProperty(object, property,
+                       {value: value, writable: true, enumerable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets configurable descriptor to false.
  */
 function addWEPropertyIfDefined(object, property, value) {
   if (value !== undefined) {
     defineWEProperty(object, property, value);
   }
 }
 
 
 /**
  * Defines a property and sets writable, enumerable and configurable to true.
  */
 function defineWECProperty(object, property, value) {
-  $Object.defineProperty(object, property,
-                         {value: value,
-                          writable: true,
-                          enumerable: true,
-                          configurable: true});
+  ObjectDefineProperty(object, property,
+                       {value: value,
+                        writable: true,
+                        enumerable: true,
+                        configurable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets all descriptors to true.
  */
 function addWECPropertyIfDefined(object, property, value) {
   if (value !== undefined) {
     defineWECProperty(object, property, value);
@@ skipping 218 matching lines @@
   } else if (internalOptions.usage === 'search') {
     extension = '-u-co-search';
   }
   defineWEProperty(internalOptions, 'collation', collation);
 
   var requestedLocale = locale.locale + extension;
 
   // We define all properties C++ code may produce, to prevent security
   // problems. If malicious user decides to redefine Object.prototype.locale
   // we can't just use plain x.locale = 'us' or in C++ Set("locale", "us").
-  // Object.defineProperties will either succeed defining or throw an error.
-  var resolved = $Object.defineProperties({}, {
+  // ObjectDefineProperties will either succeed defining or throw an error.
+  var resolved = ObjectDefineProperties({}, {
     caseFirst: {writable: true},
     collation: {value: internalOptions.collation, writable: true},
     ignorePunctuation: {writable: true},
     locale: {writable: true},
     numeric: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     sensitivity: {writable: true},
     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);
-  $Object.defineProperty(collator, 'resolved', {value: resolved});
+  ObjectDefineProperty(collator, 'resolved', {value: resolved});
 
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 176 matching lines @@
   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);
   var extension = setOptions(options, extensionMap, NUMBER_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
-  var resolved = $Object.defineProperties({}, {
+  var resolved = ObjectDefineProperties({}, {
     currency: {writable: true},
     currencyDisplay: {writable: true},
     locale: {writable: true},
     maximumFractionDigits: {writable: true},
     minimumFractionDigits: {writable: true},
     minimumIntegerDigits: {writable: true},
     numberingSystem: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     style: {value: internalOptions.style, writable: true},
     useGrouping: {writable: true}
   });
   if (internalOptions.hasOwnProperty('minimumSignificantDigits')) {
     defineWEProperty(resolved, 'minimumSignificantDigits', undefined);
   }
   if (internalOptions.hasOwnProperty('maximumSignificantDigits')) {
     defineWEProperty(resolved, 'maximumSignificantDigits', undefined);
   }
   var formatter = %CreateNumberFormat(requestedLocale,
                                       internalOptions,
                                       resolved);
 
   // We can't get information about number or currency style from ICU, so we
   // assume user request was fulfilled.
   if (internalOptions.style === 'currency') {
-    $Object.defineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
-                                                         writable: true});
+    ObjectDefineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
+                                                       writable: true});
   }
 
   %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat', formatter);
-  $Object.defineProperty(numberFormat, 'resolved', {value: resolved});
+  ObjectDefineProperty(numberFormat, 'resolved', {value: resolved});
 
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 251 matching lines @@
 
   return options;
 }
 
 
 /**
  * Returns options with at least default values in it.
  */
 function toDateTimeOptions(options, required, defaults) {
   if (options === undefined) {
-    options = null;
+    options = {};
   } else {
-    options = toObject(options);
+    options = TO_OBJECT_INLINE(options);
   }
 
-  options = $Object.apply(this, [options]);
-
   var needsDefault = true;
   if ((required === 'date' || required === 'any') &&
       (options.weekday !== undefined || options.year !== undefined ||
        options.month !== undefined || options.day !== undefined)) {
     needsDefault = false;
   }
 
   if ((required === 'time' || required === 'any') &&
       (options.hour !== undefined || options.minute !== undefined ||
        options.second !== undefined)) {
     needsDefault = false;
   }
 
   if (needsDefault && (defaults === 'date' || defaults === 'all')) {
-    $Object.defineProperty(options, 'year', {value: 'numeric',
+    ObjectDefineProperty(options, 'year', {value: 'numeric',
+                                           writable: true,
+                                           enumerable: true,
+                                           configurable: true});
+    ObjectDefineProperty(options, 'month', {value: 'numeric',
+                                            writable: true,
+                                            enumerable: true,
+                                            configurable: true});
+    ObjectDefineProperty(options, 'day', {value: 'numeric',
+                                          writable: true,
+                                          enumerable: true,
+                                          configurable: true});
+  }
+
+  if (needsDefault && (defaults === 'time' || defaults === 'all')) {
+    ObjectDefineProperty(options, 'hour', {value: 'numeric',
                                              writable: true,
                                              enumerable: true,
                                              configurable: true});
-    $Object.defineProperty(options, 'month', {value: 'numeric',
-                                              writable: true,
-                                              enumerable: true,
-                                              configurable: true});
-    $Object.defineProperty(options, 'day', {value: 'numeric',
-                                            writable: true,
-                                            enumerable: true,
-                                            configurable: true});
-  }
-
-  if (needsDefault && (defaults === 'time' || defaults === 'all')) {
-    $Object.defineProperty(options, 'hour', {value: 'numeric',
-                                             writable: true,
-                                             enumerable: true,
-                                             configurable: true});
-    $Object.defineProperty(options, 'minute', {value: 'numeric',
+    ObjectDefineProperty(options, 'minute', {value: 'numeric',
                                                writable: true,
                                                enumerable: true,
                                                configurable: true});
-    $Object.defineProperty(options, 'second', {value: 'numeric',
+    ObjectDefineProperty(options, 'second', {value: 'numeric',
                                                writable: true,
                                                enumerable: true,
                                                configurable: true});
   }
 
   return options;
 }
 
 
 /**
@@ skipping 30 matching lines @@
   var tz = canonicalizeTimeZoneID(options.timeZone);
 
   // ICU prefers options to be passed using -u- extension key/values, so
   // we need to build that.
   var internalOptions = {};
   var extensionMap = parseExtension(locale.extension);
   var extension = setOptions(options, extensionMap, DATETIME_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
-  var resolved = $Object.defineProperties({}, {
+  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},
     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 (tz !== undefined && tz !== resolved.timeZone) {
     throw new $RangeError('Unsupported time zone specified ' + tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
-  $Object.defineProperty(dateFormat, 'resolved', {value: resolved});
+  ObjectDefineProperty(dateFormat, 'resolved', {value: resolved});
 
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 173 matching lines @@
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'type', getOption(
     'type', 'string', ['character', 'word', 'sentence', 'line'], 'word'));
 
   var locale = resolveLocale('breakiterator', locales, options);
-  var resolved = $Object.defineProperties({}, {
+  var resolved = ObjectDefineProperties({}, {
     requestedLocale: {value: locale.locale, writable: true},
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
   var internalIterator = %CreateBreakIterator(locale.locale,
                                               internalOptions,
                                               resolved);
 
   %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator',
                                      internalIterator);
-  $Object.defineProperty(iterator, 'resolved', {value: resolved});
+  ObjectDefineProperty(iterator, 'resolved', {value: resolved});
 
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 145 matching lines @@
     return defaultObjects[service];
   }
   return new savedObjects[service](locales, useOptions);
 }
 
 
 /**
  * Compares this and that, and returns less than 0, 0 or greater than 0 value.
  * Overrides the built-in method.
  */
-$Object.defineProperty($String.prototype, 'localeCompare', {
+ObjectDefineProperty($String.prototype, 'localeCompare', {
   value: function(that) {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     if (IS_NULL_OR_UNDEFINED(this)) {
       throw new $TypeError('Method invoked on undefined or null value.');
     }
 
     var locales = %_Arguments(1);
@@ skipping 10 matching lines @@
 %SetNativeFlag($String.prototype.localeCompare);
 
 
 /**
  * Unicode normalization. This method is called with one argument that
  * specifies the normalization form.
  * If none is specified, "NFC" is assumed.
  * If the form is not one of "NFC", "NFD", "NFKC", or "NFKD", then throw
  * a RangeError Exception.
  */
-$Object.defineProperty($String.prototype, 'normalize', {
+ObjectDefineProperty($String.prototype, 'normalize', {
   value: function(that) {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     CHECK_OBJECT_COERCIBLE(this, "String.prototype.normalize");
 
     var form = $String(%_Arguments(0) || 'NFC');
 
     var normalizationForm = NORMALIZATION_FORMS.indexOf(form);
@@ skipping 10 matching lines @@
 });
 %FunctionSetName($String.prototype.normalize, 'normalize');
 %FunctionRemovePrototype($String.prototype.normalize);
 %SetNativeFlag($String.prototype.normalize);
 
 
 /**
  * Formats a Number object (this) using locale and options values.
  * If locale or options are omitted, defaults are used.
  */
-$Object.defineProperty($Number.prototype, 'toLocaleString', {
+ObjectDefineProperty($Number.prototype, 'toLocaleString', {
   value: function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     if (!(this instanceof $Number) && typeof(this) !== 'number') {
       throw new $TypeError('Method invoked on an object that is not Number.');
     }
 
     var locales = %_Arguments(0);
@@ skipping 29 matching lines @@
 
   return formatDate(dateFormat, date);
 }
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - both date and time are
  * present in the output.
  */
-$Object.defineProperty($Date.prototype, 'toLocaleString', {
+ObjectDefineProperty($Date.prototype, 'toLocaleString', {
   value: function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'any', 'all', 'dateformatall');
   },
   writable: true,
   configurable: true,
   enumerable: false
 });
 %FunctionSetName($Date.prototype.toLocaleString, 'toLocaleString');
 %FunctionRemovePrototype($Date.prototype.toLocaleString);
 %SetNativeFlag($Date.prototype.toLocaleString);
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only date is present
  * in the output.
  */
-$Object.defineProperty($Date.prototype, 'toLocaleDateString', {
+ObjectDefineProperty($Date.prototype, 'toLocaleDateString', {
   value: function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'date', 'date', 'dateformatdate');
   },
   writable: true,
   configurable: true,
   enumerable: false
 });
 %FunctionSetName($Date.prototype.toLocaleDateString, 'toLocaleDateString');
 %FunctionRemovePrototype($Date.prototype.toLocaleDateString);
 %SetNativeFlag($Date.prototype.toLocaleDateString);
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only time is present
  * in the output.
  */
-$Object.defineProperty($Date.prototype, 'toLocaleTimeString', {
+ObjectDefineProperty($Date.prototype, 'toLocaleTimeString', {
   value: function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   },
   writable: true,
   configurable: true,
   enumerable: false
 });
 %FunctionSetName($Date.prototype.toLocaleTimeString, 'toLocaleTimeString');
 %FunctionRemovePrototype($Date.prototype.toLocaleTimeString);
 %SetNativeFlag($Date.prototype.toLocaleTimeString);
 
 return Intl;
 }())});