Audit of user code calls, part 1

polyfill/lib/calendar.mjs

@@ -83,18 +83,7 @@ export class Calendar {
   fields(fields) {
     if (!ES.IsTemporalCalendar(this)) throw new TypeError('invalid receiver');
     const fieldsArray = [];
-    const allowed = new Set([
-      'year',
-      'month',
-      'monthCode',
-      'day',
-      'hour',
-      'minute',
-      'second',
-      'millisecond',
-      'microsecond',
-      'nanosecond'
-    ]);
+    const allowed = new Set(['year', 'month', 'monthCode', 'day']);
     for (const name of fields) {
       if (ES.Type(name) !== 'String') throw new TypeError('invalid fields');
       if (!allowed.has(name)) throw new RangeError(`invalid field name ${name}`);

polyfill/lib/ecmascript.mjs

@@ -984,19 +984,17 @@ export function ToRelativeTemporalObject(options) {
     if (IsTemporalZonedDateTime(relativeTo) || IsTemporalDate(relativeTo)) return relativeTo;
     if (IsTemporalDateTime(relativeTo)) return TemporalDateTimeToDate(relativeTo);
     calendar = GetTemporalCalendarSlotValueWithISODefault(relativeTo);
-    const fieldNames = CalendarFields(calendar, [
-      'day',
+    const fieldNames = CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
+    Call(ArrayPrototypePush, fieldNames, [
       'hour',
       'microsecond',
       'millisecond',
       'minute',
-      'month',
-      'monthCode',
       'nanosecond',
+      'offset',
       'second',
-      'year'
+      'timeZone'
     ]);
-    Call(ArrayPrototypePush, fieldNames, ['timeZone', 'offset']);
     const fields = PrepareTemporalFields(relativeTo, fieldNames, []);
     const dateOptions = ObjectCreate(null);
     dateOptions.overflow = 'constrain';
@@ -1162,6 +1160,7 @@ export function ToTemporalTimeRecord(bag, completeness = 'complete') {
 }
 
 export function ToTemporalDate(item, options) {
+  if (options !== undefined) options = SnapshotOwnProperties(GetOptionsObject(options), null);
   if (Type(item) === 'Object') {
     if (IsTemporalDate(item)) return item;
     if (IsTemporalZonedDateTime(item)) {
@@ -1182,18 +1181,19 @@ export function ToTemporalDate(item, options) {
     const fields = PrepareTemporalFields(item, fieldNames, []);
     return CalendarDateFromFields(calendar, fields, options);
   }
-  ToTemporalOverflow(options); // validate and ignore
   let { year, month, day, calendar, z } = ParseTemporalDateString(RequireString(item));
   if (z) throw new RangeError('Z designator not supported for PlainDate');
   if (!calendar) calendar = 'iso8601';
   if (!IsBuiltinCalendar(calendar)) throw new RangeError(`invalid calendar identifier ${calendar}`);
   calendar = ASCIILowercase(calendar);
+  ToTemporalOverflow(options); // validate and ignore
   return CreateTemporalDate(year, month, day, calendar);
 }
 
 export function InterpretTemporalDateTimeFields(calendar, fields, options) {
   let { hour, minute, second, millisecond, microsecond, nanosecond } = ToTemporalTimeRecord(fields);
   const overflow = ToTemporalOverflow(options);
+  options.overflow = overflow; // options is always an internal object, so not observable
   const date = CalendarDateFromFields(calendar, fields, options);
   const year = GetSlot(date, ISO_YEAR);
   const month = GetSlot(date, ISO_MONTH);
@@ -1212,14 +1212,16 @@ export function InterpretTemporalDateTimeFields(calendar, fields, options) {
 
 export function ToTemporalDateTime(item, options) {
   let year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, calendar;
+  const resolvedOptions = SnapshotOwnProperties(GetOptionsObject(options), null);
+
   if (Type(item) === 'Object') {
     if (IsTemporalDateTime(item)) return item;
     if (IsTemporalZonedDateTime(item)) {
-      ToTemporalOverflow(options); // validate and ignore
+      ToTemporalOverflow(resolvedOptions); // validate and ignore
       return GetPlainDateTimeFor(GetSlot(item, TIME_ZONE), GetSlot(item, INSTANT), GetSlot(item, CALENDAR));
     }
     if (IsTemporalDate(item)) {
-      ToTemporalOverflow(options); // validate and ignore
+      ToTemporalOverflow(resolvedOptions); // validate and ignore
       return CreateTemporalDateTime(
         GetSlot(item, ISO_YEAR),
         GetSlot(item, ISO_MONTH),
@@ -1235,26 +1237,15 @@ export function ToTemporalDateTime(item, options) {
     }
 
     calendar = GetTemporalCalendarSlotValueWithISODefault(item);
-    const fieldNames = CalendarFields(calendar, [
-      'day',
-      'hour',
-      'microsecond',
-      'millisecond',
-      'minute',
-      'month',
-      'monthCode',
-      'nanosecond',
-      'second',
-      'year'
-    ]);
+    const fieldNames = CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
+    Call(ArrayPrototypePush, fieldNames, ['hour', 'microsecond', 'millisecond', 'minute', 'nanosecond', 'second']);
     const fields = PrepareTemporalFields(item, fieldNames, []);
     ({ year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = InterpretTemporalDateTimeFields(
       calendar,
       fields,
-      options
+      resolvedOptions
     ));
   } else {
-    ToTemporalOverflow(options); // validate and ignore
     let z;
     ({ year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, calendar, z } =
       ParseTemporalDateTimeString(RequireString(item)));
@@ -1263,6 +1254,7 @@ export function ToTemporalDateTime(item, options) {
     if (!calendar) calendar = 'iso8601';
     if (!IsBuiltinCalendar(calendar)) throw new RangeError(`invalid calendar identifier ${calendar}`);
     calendar = ASCIILowercase(calendar);
+    ToTemporalOverflow(resolvedOptions); // validate and ignore
   }
   return CreateTemporalDateTime(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, calendar);
 }
@@ -1299,6 +1291,7 @@ export function ToTemporalInstant(item) {
 }
 
 export function ToTemporalMonthDay(item, options) {
+  if (options !== undefined) options = SnapshotOwnProperties(GetOptionsObject(options), null);
   if (Type(item) === 'Object') {
     if (IsTemporalMonthDay(item)) return item;
     let calendar, calendarAbsent;
@@ -1322,11 +1315,11 @@ export function ToTemporalMonthDay(item, options) {
     return CalendarMonthDayFromFields(calendar, fields, options);
   }
 
-  ToTemporalOverflow(options); // validate and ignore
   let { month, day, referenceISOYear, calendar } = ParseTemporalMonthDayString(RequireString(item));
   if (calendar === undefined) calendar = 'iso8601';
   if (!IsBuiltinCalendar(calendar)) throw new RangeError(`invalid calendar identifier ${calendar}`);
   calendar = ASCIILowercase(calendar);
+  ToTemporalOverflow(options); // validate and ignore
 
   if (referenceISOYear === undefined) {
     RejectISODate(1972, month, day);
@@ -1373,6 +1366,7 @@ export function ToTemporalTime(item, overflow = 'constrain') {
 }
 
 export function ToTemporalYearMonth(item, options) {
+  if (options !== undefined) options = SnapshotOwnProperties(GetOptionsObject(options), null);
   if (Type(item) === 'Object') {
     if (IsTemporalYearMonth(item)) return item;
     const calendar = GetTemporalCalendarSlotValueWithISODefault(item);
@@ -1381,11 +1375,11 @@ export function ToTemporalYearMonth(item, options) {
     return CalendarYearMonthFromFields(calendar, fields, options);
   }
 
-  ToTemporalOverflow(options); // validate and ignore
   let { year, month, referenceISODay, calendar } = ParseTemporalYearMonthString(RequireString(item));
   if (calendar === undefined) calendar = 'iso8601';
   if (!IsBuiltinCalendar(calendar)) throw new RangeError(`invalid calendar identifier ${calendar}`);
   calendar = ASCIILowercase(calendar);
+  ToTemporalOverflow(options); // validate and ignore
 
   if (referenceISODay === undefined) {
     RejectISODate(year, month, 1);
@@ -1468,37 +1462,36 @@ export function InterpretISODateTimeOffset(
 
 export function ToTemporalZonedDateTime(item, options) {
   let year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, timeZone, offset, calendar;
+  const resolvedOptions = SnapshotOwnProperties(GetOptionsObject(options), null);
   let disambiguation, offsetOpt;
   let matchMinute = false;
   let offsetBehaviour = 'option';
   if (Type(item) === 'Object') {
     if (IsTemporalZonedDateTime(item)) return item;
     calendar = GetTemporalCalendarSlotValueWithISODefault(item);
-    const fieldNames = CalendarFields(calendar, [
-      'day',
+    const fieldNames = CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
+    Call(ArrayPrototypePush, fieldNames, [
       'hour',
       'microsecond',
       'millisecond',
       'minute',
-      'month',
-      'monthCode',
       'nanosecond',
+      'offset',
       'second',
-      'year'
+      'timeZone'
     ]);
-    Call(ArrayPrototypePush, fieldNames, ['timeZone', 'offset']);
     const fields = PrepareTemporalFields(item, fieldNames, ['timeZone']);
     timeZone = ToTemporalTimeZoneSlotValue(fields.timeZone);
     offset = fields.offset;
     if (offset === undefined) {
       offsetBehaviour = 'wall';
     }
-    disambiguation = ToTemporalDisambiguation(options);
-    offsetOpt = ToTemporalOffset(options, 'reject');
+    disambiguation = ToTemporalDisambiguation(resolvedOptions);
+    offsetOpt = ToTemporalOffset(resolvedOptions, 'reject');
     ({ year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = InterpretTemporalDateTimeFields(
       calendar,
       fields,
-      options
+      resolvedOptions
     ));
   } else {
     let tzAnnotation, z;
@@ -1527,9 +1520,9 @@ export function ToTemporalZonedDateTime(item, options) {
     if (!IsBuiltinCalendar(calendar)) throw new RangeError(`invalid calendar identifier ${calendar}`);
     calendar = ASCIILowercase(calendar);
     matchMinute = true; // ISO strings may specify offset with less precision
-    disambiguation = ToTemporalDisambiguation(options);
-    offsetOpt = ToTemporalOffset(options, 'reject');
-    ToTemporalOverflow(options); // validate and ignore
+    disambiguation = ToTemporalDisambiguation(resolvedOptions);
+    offsetOpt = ToTemporalOffset(resolvedOptions, 'reject');
+    ToTemporalOverflow(resolvedOptions); // validate and ignore
   }
   let offsetNs = 0;
   if (offsetBehaviour === 'option') offsetNs = ParseDateTimeUTCOffset(offset);
@@ -2264,9 +2257,9 @@ export function FormatUTCOffsetNanoseconds(offsetNs) {
   return `${sign}${timeString}`;
 }
 
-export function GetPlainDateTimeFor(timeZone, instant, calendar) {
+export function GetPlainDateTimeFor(timeZone, instant, calendar, precalculatedOffsetNs = undefined) {
   const ns = GetSlot(instant, EPOCHNANOSECONDS);
-  const offsetNs = GetOffsetNanosecondsFor(timeZone, instant);
+  const offsetNs = precalculatedOffsetNs ?? GetOffsetNanosecondsFor(timeZone, instant);
   let { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = GetISOPartsFromEpoch(ns);
   ({ year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } = BalanceISODateTime(
     year,
@@ -2474,11 +2467,11 @@ export function FormatTimeString(hour, minute, second, subSecondNanoseconds, pre
 export function TemporalInstantToString(instant, timeZone, precision) {
   let outputTimeZone = timeZone;
   if (outputTimeZone === undefined) outputTimeZone = 'UTC';
-  const dateTime = GetPlainDateTimeFor(outputTimeZone, instant, 'iso8601');
+  const offsetNs = GetOffsetNanosecondsFor(outputTimeZone, instant);
+  const dateTime = GetPlainDateTimeFor(outputTimeZone, instant, 'iso8601', offsetNs);
   const dateTimeString = TemporalDateTimeToString(dateTime, precision, 'never');
   let timeZoneString = 'Z';
   if (timeZone !== undefined) {
-    const offsetNs = GetOffsetNanosecondsFor(outputTimeZone, instant);
     timeZoneString = FormatDateTimeUTCOffsetRounded(offsetNs);
   }
   return `${dateTimeString}${timeZoneString}`;
@@ -2632,10 +2625,10 @@ export function TemporalZonedDateTimeToString(
   }
 
   const tz = GetSlot(zdt, TIME_ZONE);
-  const dateTime = GetPlainDateTimeFor(tz, instant, 'iso8601');
+  const offsetNs = GetOffsetNanosecondsFor(tz, instant);
+  const dateTime = GetPlainDateTimeFor(tz, instant, 'iso8601', offsetNs);
   let dateTimeString = TemporalDateTimeToString(dateTime, precision, 'never');
   if (showOffset !== 'never') {
-    const offsetNs = GetOffsetNanosecondsFor(tz, instant);
     dateTimeString += FormatDateTimeUTCOffsetRounded(offsetNs);
   }
   if (showTimeZone !== 'never') {

polyfill/lib/plaindate.mjs

@@ -95,7 +95,7 @@ export class PlainDate {
       throw new TypeError('invalid argument');
     }
     ES.RejectTemporalLikeObject(temporalDateLike);
-    options = ES.GetOptionsObject(options);
+    const resolvedOptions = ES.SnapshotOwnProperties(ES.GetOptionsObject(options), null);
 
     const calendar = GetSlot(this, CALENDAR);
     const fieldNames = ES.CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
@@ -104,7 +104,7 @@ export class PlainDate {
     fields = ES.CalendarMergeFields(calendar, fields, partialDate);
     fields = ES.PrepareTemporalFields(fields, fieldNames, []);
 
-    return ES.CalendarDateFromFields(calendar, fields, options);
+    return ES.CalendarDateFromFields(calendar, fields, resolvedOptions);
   }
   withCalendar(calendar) {
     if (!ES.IsTemporalDate(this)) throw new TypeError('invalid receiver');

polyfill/lib/plaindatetime.mjs

@@ -17,6 +17,7 @@ import {
   GetSlot
 } from './slots.mjs';
 
+const ArrayPrototypePush = Array.prototype.push;
 const ObjectCreate = Object.create;
 
 export class PlainDateTime {
@@ -152,26 +153,22 @@ export class PlainDateTime {
     }
     ES.RejectTemporalLikeObject(temporalDateTimeLike);
 
-    options = ES.GetOptionsObject(options);
+    const resolvedOptions = ES.SnapshotOwnProperties(ES.GetOptionsObject(options), null);
     const calendar = GetSlot(this, CALENDAR);
-    const fieldNames = ES.CalendarFields(calendar, [
-      'day',
-      'hour',
-      'microsecond',
-      'millisecond',
-      'minute',
-      'month',
-      'monthCode',
-      'nanosecond',
-      'second',
-      'year'
-    ]);
+    const fieldNames = ES.CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
     let fields = ES.PrepareTemporalFields(this, fieldNames, []);
+    fields.hour = GetSlot(this, ISO_HOUR);
+    fields.minute = GetSlot(this, ISO_MINUTE);
+    fields.second = GetSlot(this, ISO_SECOND);
+    fields.millisecond = GetSlot(this, ISO_MILLISECOND);
+    fields.microsecond = GetSlot(this, ISO_MICROSECOND);
+    fields.nanosecond = GetSlot(this, ISO_NANOSECOND);
+    ES.Call(ArrayPrototypePush, fieldNames, ['hour', 'microsecond', 'millisecond', 'minute', 'nanosecond', 'second']);
     const partialDateTime = ES.PrepareTemporalFields(temporalDateTimeLike, fieldNames, 'partial');
     fields = ES.CalendarMergeFields(calendar, fields, partialDateTime);
     fields = ES.PrepareTemporalFields(fields, fieldNames, []);
     const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } =
-      ES.InterpretTemporalDateTimeFields(calendar, fields, options);
+      ES.InterpretTemporalDateTimeFields(calendar, fields, resolvedOptions);
 
     return ES.CreateTemporalDateTime(
       year,

polyfill/lib/plainmonthday.mjs

@@ -35,7 +35,7 @@ export class PlainMonthDay {
       throw new TypeError('invalid argument');
     }
     ES.RejectTemporalLikeObject(temporalMonthDayLike);
-    options = ES.GetOptionsObject(options);
+    const resolvedOptions = ES.SnapshotOwnProperties(ES.GetOptionsObject(options), null);
 
     const calendar = GetSlot(this, CALENDAR);
     const fieldNames = ES.CalendarFields(calendar, ['day', 'month', 'monthCode', 'year']);
@@ -44,7 +44,7 @@ export class PlainMonthDay {
     fields = ES.CalendarMergeFields(calendar, fields, partialMonthDay);
     fields = ES.PrepareTemporalFields(fields, fieldNames, []);
 
-    return ES.CalendarMonthDayFromFields(calendar, fields, options);
+    return ES.CalendarMonthDayFromFields(calendar, fields, resolvedOptions);
   }
   equals(other) {
     if (!ES.IsTemporalMonthDay(this)) throw new TypeError('invalid receiver');

polyfill/lib/plainyearmonth.mjs

@@ -61,7 +61,7 @@ export class PlainYearMonth {
       throw new TypeError('invalid argument');
     }
     ES.RejectTemporalLikeObject(temporalYearMonthLike);
-    options = ES.GetOptionsObject(options);
+    const resolvedOptions = ES.SnapshotOwnProperties(ES.GetOptionsObject(options), null);
 
     const calendar = GetSlot(this, CALENDAR);
     const fieldNames = ES.CalendarFields(calendar, ['month', 'monthCode', 'year']);
@@ -70,7 +70,7 @@ export class PlainYearMonth {
     fields = ES.CalendarMergeFields(calendar, fields, partialYearMonth);
     fields = ES.PrepareTemporalFields(fields, fieldNames, []);
 
-    return ES.CalendarYearMonthFromFields(calendar, fields, options);
+    return ES.CalendarYearMonthFromFields(calendar, fields, resolvedOptions);
   }
   add(temporalDurationLike, options = undefined) {
     if (!ES.IsTemporalYearMonth(this)) throw new TypeError('invalid receiver');