Rebase: Replace GetEpochFromISOParts with GetUTCEpochNanoseconds

GetEpochFromISOParts was already merged into ECMA-262 and renamed to
GetUTCEpochNanoseconds. Its IsValidISODate assertion was removed, so add
that in the one place where it isn't redundant.

Author: ptomato

polyfill/lib/ecmascript.mjs

@@ -519,7 +519,7 @@ export const ES = ObjectAssign({}, ES2022, {
       microsecond,
       nanosecond - offsetNs
     ));
-    const epochNs = ES.GetEpochFromISOParts(
+    const epochNs = ES.GetUTCEpochNanoseconds(
       year,
       month,
       day,
@@ -1247,7 +1247,7 @@ export const ES = ObjectAssign({}, ES2022, {
     // for this timezone and date/time.
     if (offsetBehaviour === 'exact' || offsetOpt === 'use') {
       // Calculate the instant for the input's date/time and offset
-      const epochNs = ES.GetEpochFromISOParts(
+      const epochNs = ES.GetUTCEpochNanoseconds(
         year,
         month,
         day,
@@ -1785,7 +1785,17 @@ export const ES = ObjectAssign({}, ES2022, {
     const millisecond = GetSlot(dateTime, ISO_MILLISECOND);
     const microsecond = GetSlot(dateTime, ISO_MICROSECOND);
     const nanosecond = GetSlot(dateTime, ISO_NANOSECOND);
-    const utcns = ES.GetEpochFromISOParts(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
+    const utcns = ES.GetUTCEpochNanoseconds(
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      millisecond,
+      microsecond,
+      nanosecond
+    );
     if (utcns === null) throw new RangeError('DateTime outside of supported range');
     const dayBefore = new Instant(utcns.minus(86400e9));
     const dayAfter = new Instant(utcns.plus(86400e9));
@@ -2153,7 +2163,7 @@ export const ES = ObjectAssign({}, ES2022, {
   GetIANATimeZoneOffsetNanoseconds: (epochNanoseconds, id) => {
     const { year, month, day, hour, minute, second, millisecond, microsecond, nanosecond } =
       ES.GetIANATimeZoneDateTimeParts(epochNanoseconds, id);
-    const utc = ES.GetEpochFromISOParts(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
+    const utc = ES.GetUTCEpochNanoseconds(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
     if (utc === null) throw new RangeError('Date outside of supported range');
     return +utc.minus(epochNanoseconds);
   },
@@ -2189,7 +2199,7 @@ export const ES = ObjectAssign({}, ES2022, {
     const minuteString = ES.ISODateTimePartString(minutes);
     return `${sign}${hourString}:${minuteString}`;
   },
-  GetEpochFromISOParts: (year, month, day, hour, minute, second, millisecond, microsecond, nanosecond) => {
+  GetUTCEpochNanoseconds: (year, month, day, hour, minute, second, millisecond, microsecond, nanosecond) => {
     // Note: Date.UTC() interprets one and two-digit years as being in the
     // 20th century, so don't use it
     const legacyDate = new Date();
@@ -2310,7 +2320,7 @@ export const ES = ObjectAssign({}, ES2022, {
     };
   },
   GetIANATimeZoneEpochValue: (id, year, month, day, hour, minute, second, millisecond, microsecond, nanosecond) => {
-    let ns = ES.GetEpochFromISOParts(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
+    let ns = ES.GetUTCEpochNanoseconds(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond);
     if (ns === null) throw new RangeError('DateTime outside of supported range');
     let nsEarlier = ns.minus(DAY_NANOS);
     if (nsEarlier.lesser(NS_MIN)) nsEarlier = ns;
@@ -3048,7 +3058,7 @@ export const ES = ObjectAssign({}, ES2022, {
     if (
       (year === YEAR_MIN &&
         null ==
-          ES.GetEpochFromISOParts(
+          ES.GetUTCEpochNanoseconds(
             year,
             month,
             day + 1,
@@ -3061,7 +3071,17 @@ export const ES = ObjectAssign({}, ES2022, {
           )) ||
       (year === YEAR_MAX &&
         null ==
-          ES.GetEpochFromISOParts(year, month, day - 1, hour, minute, second, millisecond, microsecond, nanosecond + 1))
+          ES.GetUTCEpochNanoseconds(
+            year,
+            month,
+            day - 1,
+            hour,
+            minute,
+            second,
+            millisecond,
+            microsecond,
+            nanosecond + 1
+          ))
     ) {
       throw new RangeError('DateTime outside of supported range');
     }

polyfill/lib/timezone.mjs

@@ -80,7 +80,7 @@ export class TimeZone {
     const id = GetSlot(this, TIMEZONE_ID);
 
     if (ES.TestTimeZoneOffsetString(id)) {
-      const epochNs = ES.GetEpochFromISOParts(
+      const epochNs = ES.GetUTCEpochNanoseconds(
         GetSlot(dateTime, ISO_YEAR),
         GetSlot(dateTime, ISO_MONTH),
         GetSlot(dateTime, ISO_DAY),

spec/instant.html

@@ -522,7 +522,7 @@ <h1>ParseTemporalInstant ( _isoString_ )</h1>
         1. Let _result_ be ? ParseTemporalInstantString(_isoString_).
         1. Let _offsetString_ be _result_.[[TimeZoneOffsetString]].
         1. Assert: _offsetString_ is not *undefined*.
-        1. Let _utc_ be GetEpochFromISOParts(_result_.[[Year]], _result_.[[Month]], _result_.[[Day]], _result_.[[Hour]], _result_.[[Minute]], _result_.[[Second]], _result_.[[Millisecond]], _result_.[[Microsecond]], _result_.[[Nanosecond]]).
+        1. Let _utc_ be GetUTCEpochNanoseconds(_result_.[[Year]], _result_.[[Month]], _result_.[[Day]], _result_.[[Hour]], _result_.[[Minute]], _result_.[[Second]], _result_.[[Millisecond]], _result_.[[Microsecond]], _result_.[[Nanosecond]]).
         1. Let _offsetNanoseconds_ be ? ParseTimeZoneOffsetString(_offsetString_).
         1. Let _result_ be _utc_ - ℤ(_offsetNanoseconds_).
         1. If ! IsValidEpochNanoseconds(_result_) is *false*, then

spec/plaindatetime.html

@@ -789,34 +789,6 @@ <h1>Properties of Temporal.PlainDateTime Instances</h1>
   <emu-clause id="sec-temporal-plaindatetime-abstract-ops">
     <h1>Abstract operations</h1>
 
-    <emu-clause id="sec-temporal-getepochfromisoparts" type="abstract operation">
-      <h1>
-        GetEpochFromISOParts (
-          _year_: an integer,
-          _month_: an integer between 1 and 12 inclusive,
-          _day_: an integer between 1 and 31 inclusive,
-          _hour_: an integer between 0 and 23 inclusive,
-          _minute_: an integer between 0 and 59 inclusive,
-          _second_: an integer between 0 and 59 inclusive,
-          _millisecond_: an integer between 0 and 999 inclusive,
-          _microsecond_: an integer between 0 and 999 inclusive,
-          _nanosecond_: an integer between 0 and 999 inclusive,
-        ): a BigInt
-      </h1>
-      <dl class="header">
-        <dt>description</dt>
-        <dd>The returned value represents a number of nanoseconds since the Unix epoch in UTC that corresponds to the given ISO 8601 calendar date and wall-clock time in UTC.</dd>
-      </dl>
-      <emu-alg>
-        1. Assert: IsValidISODate(_year_, _month_, _day_) is *true*.
-        1. Let _date_ be MakeDay(𝔽(_year_), 𝔽(_month_ - 1), 𝔽(_day_)).
-        1. Let _time_ be MakeTime(𝔽(_hour_), 𝔽(_minute_), 𝔽(_second_), 𝔽(_millisecond_)).
-        1. Let _ms_ be MakeDate(_date_, _time_).
-        1. Assert: _ms_ is finite.
-        1. Return ℤ(ℝ(_ms_) &times; 10<sup>6</sup> + _microsecond_ &times; 10<sup>3</sup> + _nanosecond_).
-      </emu-alg>
-    </emu-clause>
-
     <emu-clause id="sec-temporal-isodatetimewithinlimits" type="abstract operation">
       <h1>
         ISODateTimeWithinLimits (
@@ -843,7 +815,7 @@ <h1>
       </emu-note>
       <emu-alg>
         1. Assert: IsValidISODate(_year_, _month_, _day_) is *true*.
-        1. Let _ns_ be ℝ(GetEpochFromISOParts(_year_, _month_, _day_, _hour_, _minute_, _second_, _millisecond_, _microsecond_, _nanosecond_)).
+        1. Let _ns_ be ℝ(GetUTCEpochNanoseconds(_year_, _month_, _day_, _hour_, _minute_, _second_, _millisecond_, _microsecond_, _nanosecond_)).
         1. If _ns_ &le; nsMinInstant - nsPerDay, then
           1. Return *false*.
         1. If _ns_ &ge; nsMaxInstant + nsPerDay, then

spec/timezone.html

@@ -271,7 +271,7 @@ <h1>Temporal.TimeZone.prototype.getPossibleInstantsFor ( _dateTime_ )</h1>
         1. Perform ? RequireInternalSlot(_timeZone_, [[InitializedTemporalTimezone]]).
         1. Set _dateTime_ to ? ToTemporalDateTime(_dateTime_).
         1. If _timeZone_.[[OffsetNanoseconds]] is not *undefined*, then
-          1. Let _epochNanoseconds_ be GetEpochFromISOParts(_dateTime_.[[ISOYear]], _dateTime_.[[ISOMonth]], _dateTime_.[[ISODay]], _dateTime_.[[ISOHour]], _dateTime_.[[ISOMinute]], _dateTime_.[[ISOSecond]], _dateTime_.[[ISOMillisecond]], _dateTime_.[[ISOMicrosecond]], _dateTime_.[[ISONanosecond]]).
+          1. Let _epochNanoseconds_ be GetUTCEpochNanoseconds(_dateTime_.[[ISOYear]], _dateTime_.[[ISOMonth]], _dateTime_.[[ISODay]], _dateTime_.[[ISOHour]], _dateTime_.[[ISOMinute]], _dateTime_.[[ISOSecond]], _dateTime_.[[ISOMillisecond]], _dateTime_.[[ISOMicrosecond]], _dateTime_.[[ISONanosecond]]).
           1. Let _possibleEpochNanoseconds_ be « _epochNanoseconds_ - ℤ(_timeZone_.[[OffsetNanoseconds]]) ».
         1. Else,
           1. Let _possibleEpochNanoseconds_ be GetIANATimeZoneEpochValue(_timeZone_.[[Identifier]], _dateTime_.[[ISOYear]], _dateTime_.[[ISOMonth]], _dateTime_.[[ISODay]], _dateTime_.[[ISOHour]], _dateTime_.[[ISOMinute]], _dateTime_.[[ISOSecond]], _dateTime_.[[ISOMillisecond]], _dateTime_.[[ISOMicrosecond]], _dateTime_.[[ISONanosecond]]).
@@ -701,7 +701,7 @@ <h1>DisambiguatePossibleInstants ( _possibleInstants_, _timeZone_, _dateTime_, _
         1. Assert: _n_ = 0.
         1. If _disambiguation_ is *"reject"*, then
           1. Throw a *RangeError* exception.
-        1. Let _epochNanoseconds_ be GetEpochFromISOParts(_dateTime_.[[ISOYear]], _dateTime_.[[ISOMonth]], _dateTime_.[[ISODay]], _dateTime_.[[ISOHour]], _dateTime_.[[ISOMinute]], _dateTime_.[[ISOSecond]], _dateTime_.[[ISOMillisecond]], _dateTime_.[[ISOMicrosecond]], _dateTime_.[[ISONanosecond]]).
+        1. Let _epochNanoseconds_ be GetUTCEpochNanoseconds(_dateTime_.[[ISOYear]], _dateTime_.[[ISOMonth]], _dateTime_.[[ISODay]], _dateTime_.[[ISOHour]], _dateTime_.[[ISOMinute]], _dateTime_.[[ISOSecond]], _dateTime_.[[ISOMillisecond]], _dateTime_.[[ISOMicrosecond]], _dateTime_.[[ISONanosecond]]).
         1. Let _dayBeforeNs_ be _epochNanoseconds_ - ℤ(nsPerDay).
         1. If ! IsValidEpochNanoseconds(_dayBeforeNs_) is *false*, throw a *RangeError* exception.
         1. Let _dayBefore_ be ! CreateTemporalInstant(_dayBeforeNs_).

spec/zoneddatetime.html

@@ -1045,13 +1045,14 @@ <h1>
         </dd>
       </dl>
       <emu-alg>
+        1. Assert: IsValidISODate(_year_, _month_, _day_) is *true*.
         1. Let _calendar_ be ! GetISO8601Calendar().
         1. Let _dateTime_ be ? CreateTemporalDateTime(_year_, _month_, _day_, _hour_, _minute_, _second_, _millisecond_, _microsecond_, _nanosecond_, _calendar_).
         1. If _offsetBehaviour_ is ~wall~ or _offsetOption_ is *"ignore"*, then
           1. Let _instant_ be ? BuiltinTimeZoneGetInstantFor(_timeZone_, _dateTime_, _disambiguation_).
           1. Return _instant_.[[Nanoseconds]].
         1. If _offsetBehaviour_ is ~exact~ or _offsetOption_ is *"use"*, then
-          1. Let _epochNanoseconds_ be GetEpochFromISOParts(_year_, _month_, _day_, _hour_, _minute_, _second_, _millisecond_, _microsecond_, _nanosecond_).
+          1. Let _epochNanoseconds_ be GetUTCEpochNanoseconds(_year_, _month_, _day_, _hour_, _minute_, _second_, _millisecond_, _microsecond_, _nanosecond_).
           1. Set _epochNanoseconds_ to _epochNanoseconds_ - ℤ(_offsetNanoseconds_).
           1. If ! IsValidEpochNanoseconds(_epochNanoseconds_) is *false*, throw a *RangeError* exception.
           1. Return _epochNanoseconds_.