Use CreateTemporalInstant when internally creating instances of Instant

This is what we do for the other types as well. It reduces repetition of
GetIntrinsic('%Temporal.Instant%') It is also marginally better
performance-wise, as it skips the checks for converting external bigint
values to JSBI.

Author: ptomato

lib/ecmascript.ts

@@ -1513,11 +1513,10 @@ export function ToTemporalDuration(item: DurationParams['from'][0]) {
 }
 
 export function ToTemporalInstant(itemParam: InstantParams['from'][0]) {
-  const TemporalInstant = GetIntrinsic('%Temporal.Instant%');
   let item: string | number;
   if (IsObject(itemParam)) {
     if (IsTemporalInstant(itemParam) || IsTemporalZonedDateTime(itemParam)) {
-      return new TemporalInstant(GetSlot(itemParam, EPOCHNANOSECONDS));
+      return CreateTemporalInstant(GetSlot(itemParam, EPOCHNANOSECONDS));
     }
     item = ToPrimitive(itemParam, String);
   } else {
@@ -1548,8 +1547,7 @@ export function ToTemporalInstant(itemParam: InstantParams['from'][0]) {
   );
   CheckISODaysRange(balanced.isoDate);
   const epochNanoseconds = GetUTCEpochNanoseconds(balanced);
-  ValidateEpochNanoseconds(epochNanoseconds);
-  return new TemporalInstant(epochNanoseconds);
+  return CreateTemporalInstant(epochNanoseconds);
 }
 
 export function ToTemporalMonthDay(item: PlainMonthDayParams['from'][0], options?: PlainMonthDayParams['from'][1]) {
@@ -1935,6 +1933,30 @@ export function CreateTemporalYearMonth(isoDate: ISODate, calendar: BuiltinCalen
   return result;
 }
 
+export function CreateTemporalInstantSlots(result: Temporal.Instant, epochNanoseconds: JSBI) {
+  ValidateEpochNanoseconds(epochNanoseconds);
+  CreateSlots(result);
+  SetSlot(result, EPOCHNANOSECONDS, epochNanoseconds);
+
+  if (DEBUG) {
+    const iso = GetISOPartsFromEpoch(epochNanoseconds);
+    const repr = ISODateTimeToString(iso, 'iso8601', 'auto', 'never') + 'Z';
+    Object.defineProperty(result, '_repr_', {
+      value: `${result[Symbol.toStringTag]} <${repr}>`,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+}
+
+export function CreateTemporalInstant(epochNanoseconds: JSBI) {
+  const TemporalInstant = GetIntrinsic('%Temporal.Instant%');
+  const result: Temporal.Instant = Object.create(TemporalInstant.prototype);
+  CreateTemporalInstantSlots(result, epochNanoseconds);
+  return result;
+}
+
 export function CreateTemporalZonedDateTimeSlots(
   result: Temporal.ZonedDateTime,
   epochNanoseconds: JSBI,
@@ -2684,7 +2706,7 @@ function GetUTCEpochNanoseconds(isoDateTime: ISODateTime) {
   return JSBI.add(epochMsToNs(ms), JSBI.BigInt(subMs));
 }
 
-export function GetISOPartsFromEpoch(epochNanoseconds: JSBI) {
+function GetISOPartsFromEpoch(epochNanoseconds: JSBI) {
   let epochMilliseconds = epochNsToMs(epochNanoseconds, 'trunc');
   let nanos = JSBI.toNumber(JSBI.remainder(epochNanoseconds, MILLION));
   if (nanos < 0) {
@@ -3196,7 +3218,7 @@ function AssertISODateTimeWithinLimits(isoDateTime: ISODateTime) {
 // In the spec, IsValidEpochNanoseconds returns a boolean and call sites are
 // responsible for throwing. In the polyfill, ValidateEpochNanoseconds takes its
 // place so that we can DRY the throwing code.
-export function ValidateEpochNanoseconds(epochNanoseconds: JSBI) {
+function ValidateEpochNanoseconds(epochNanoseconds: JSBI) {
   if (JSBI.lessThan(epochNanoseconds, NS_MIN) || JSBI.greaterThan(epochNanoseconds, NS_MAX)) {
     throw new RangeError('date/time value is outside of supported range');
   }
@@ -4455,8 +4477,7 @@ export function AddDurationToInstant(
   }
   const internalDuration = ToInternalDurationRecordWith24HourDays(duration);
   const ns = AddInstant(GetSlot(instant, EPOCHNANOSECONDS), internalDuration.time);
-  const Instant = GetIntrinsic('%Temporal.Instant%');
-  return new Instant(ns);
+  return CreateTemporalInstant(ns);
 }
 
 export function AddDurationToDate(

lib/instant.ts

@@ -1,7 +1,6 @@
-import { DEBUG } from './debug';
 import * as ES from './ecmascript';
 import { MakeIntrinsicClass } from './intrinsicclass';
-import { EPOCHNANOSECONDS, CreateSlots, GetSlot, SetSlot } from './slots';
+import { EPOCHNANOSECONDS, GetSlot } from './slots';
 import type { Temporal } from '..';
 import { DateTimeFormat } from './intl';
 import type { InstantParams as Params, InstantReturn as Return } from './internaltypes';
@@ -17,20 +16,7 @@ export class Instant implements Temporal.Instant {
     }
 
     const ns = ES.ToBigInt(epochNanoseconds);
-    ES.ValidateEpochNanoseconds(ns);
-    CreateSlots(this);
-    SetSlot(this, EPOCHNANOSECONDS, ns);
-
-    if (DEBUG) {
-      const iso = ES.GetISOPartsFromEpoch(ns);
-      const repr = ES.ISODateTimeToString(iso, 'iso8601', 'auto', 'never') + 'Z';
-      Object.defineProperty(this, '_repr_', {
-        value: `${this[Symbol.toStringTag]} <${repr}>`,
-        writable: false,
-        enumerable: false,
-        configurable: false
-      });
-    }
+    ES.CreateTemporalInstantSlots(this, ns);
   }
 
   get epochMilliseconds(): Return['epochMilliseconds'] {
@@ -80,7 +66,7 @@ export class Instant implements Temporal.Instant {
     ES.ValidateTemporalRoundingIncrement(roundingIncrement, maximumIncrements[smallestUnit], true);
     const ns = GetSlot(this, EPOCHNANOSECONDS);
     const roundedNs = ES.RoundTemporalInstant(ns, roundingIncrement, smallestUnit, roundingMode);
-    return new Instant(roundedNs);
+    return ES.CreateTemporalInstant(roundedNs);
   }
   equals(otherParam: Params['equals'][0]): Return['equals'] {
     ES.CheckReceiver(this, ES.IsTemporalInstant);
@@ -101,7 +87,7 @@ export class Instant implements Temporal.Instant {
     const { precision, unit, increment } = ES.ToSecondsStringPrecisionRecord(smallestUnit, digits);
     const ns = GetSlot(this, EPOCHNANOSECONDS);
     const roundedNs = ES.RoundTemporalInstant(ns, increment, unit, roundingMode);
-    const roundedInstant = new Instant(roundedNs);
+    const roundedInstant = ES.CreateTemporalInstant(roundedNs);
     return ES.TemporalInstantToString(roundedInstant, timeZone, precision);
   }
   toJSON(): string {
@@ -126,15 +112,13 @@ export class Instant implements Temporal.Instant {
 
   static fromEpochMilliseconds(epochMilliseconds: Params['fromEpochMilliseconds'][0]): Return['fromEpochMilliseconds'] {
     const epochNanoseconds = ES.epochMsToNs(ES.ToNumber(epochMilliseconds));
-    ES.ValidateEpochNanoseconds(epochNanoseconds);
-    return new Instant(epochNanoseconds);
+    return ES.CreateTemporalInstant(epochNanoseconds);
   }
   static fromEpochNanoseconds(
     epochNanosecondsParam: Params['fromEpochNanoseconds'][0]
   ): Return['fromEpochNanoseconds'] {
     const epochNanoseconds = ES.ToBigInt(epochNanosecondsParam);
-    ES.ValidateEpochNanoseconds(epochNanoseconds);
-    return new Instant(epochNanoseconds);
+    return ES.CreateTemporalInstant(epochNanoseconds);
   }
   static from(item: Params['from'][0]): Return['from'] {
     return ES.ToTemporalInstant(item);

lib/legacydate.ts

@@ -1,5 +1,4 @@
 import * as ES from './ecmascript';
-import { Instant } from './instant';
 
 // By default, a plain function can be called as a constructor. A method such as
 // Date.prototype.toTemporalInstant should not be able to. We could check
@@ -11,7 +10,7 @@ import { Instant } from './instant';
 class LegacyDateImpl {
   toTemporalInstant(this: Date) {
     const epochNanoseconds = ES.epochMsToNs(Date.prototype.valueOf.call(this));
-    return new Instant(epochNanoseconds);
+    return ES.CreateTemporalInstant(epochNanoseconds);
   }
 }
 

lib/now.ts

@@ -1,14 +1,12 @@
 import * as ES from './ecmascript';
-import { GetIntrinsic } from './intrinsicclass';
 import type { Temporal } from '..';
 
 function SystemDateTime(timeZone: string) {
   return ES.GetISODateTimeFor(timeZone, ES.SystemUTCEpochNanoSeconds());
 }
 
 const instant: (typeof Temporal.Now)['instant'] = () => {
-  const Instant = GetIntrinsic('%Temporal.Instant%');
-  return new Instant(ES.SystemUTCEpochNanoSeconds());
+  return ES.CreateTemporalInstant(ES.SystemUTCEpochNanoSeconds());
 };
 const plainDateTimeISO: (typeof Temporal.Now)['plainDateTimeISO'] = (temporalTimeZoneLike = ES.DefaultTimeZone()) => {
   const timeZone = ES.ToTemporalTimeZoneIdentifier(temporalTimeZoneLike);

lib/zoneddatetime.ts

@@ -1,6 +1,6 @@
 import { assert } from './assert';
 import * as ES from './ecmascript';
-import { GetIntrinsic, MakeIntrinsicClass } from './intrinsicclass';
+import { MakeIntrinsicClass } from './intrinsicclass';
 import { CALENDAR, EPOCHNANOSECONDS, TIME, TIME_ZONE, GetSlot } from './slots';
 import { TimeDuration } from './timeduration';
 import type { Temporal } from '..';
@@ -397,8 +397,7 @@ export class ZonedDateTime implements Temporal.ZonedDateTime {
       );
     }
 
-    const Instant = GetIntrinsic('%Temporal.Instant%');
-    return formatter.format(new Instant(GetSlot(this, EPOCHNANOSECONDS)));
+    return formatter.format(ES.CreateTemporalInstant(GetSlot(this, EPOCHNANOSECONDS)));
   }
   toJSON(): Return['toJSON'] {
     ES.CheckReceiver(this, ES.IsTemporalZonedDateTime);
@@ -440,8 +439,7 @@ export class ZonedDateTime implements Temporal.ZonedDateTime {
   }
   toInstant(): Return['toInstant'] {
     ES.CheckReceiver(this, ES.IsTemporalZonedDateTime);
-    const TemporalInstant = GetIntrinsic('%Temporal.Instant%');
-    return new TemporalInstant(GetSlot(this, EPOCHNANOSECONDS));
+    return ES.CreateTemporalInstant(GetSlot(this, EPOCHNANOSECONDS));
   }
   toPlainDate(): Return['toPlainDate'] {
     ES.CheckReceiver(this, ES.IsTemporalZonedDateTime);