Port commits from proposal repo (2024-02-25 tranche)

.eslintrc.yml

@@ -18,9 +18,9 @@ globals:
   globalThis: readonly
 ignorePatterns:
   - node_modules/
-  - /dist/
-  - /tsc-out/
-  - /test262/
+  - dist/
+  - tsc-out/
+  - test262/
 rules:
   array-element-newline:
     - error

.prettierignore

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+tsc-out/
+test262/

index.d.ts

@@ -1138,6 +1138,7 @@ export namespace Temporal {
     static from(timeZone: TimeZoneLike): Temporal.TimeZone | TimeZoneProtocol;
     constructor(timeZoneIdentifier: string);
     readonly id: string;
+    equals(timeZone: TimeZoneLike): boolean;
     getOffsetNanosecondsFor(instant: Temporal.Instant | string): number;
     getOffsetStringFor(instant: Temporal.Instant | string): string;
     getPlainDateTimeFor(instant: Temporal.Instant | string, calendar?: CalendarLike): Temporal.PlainDateTime;

lib/calendar.ts

@@ -29,19 +29,23 @@ import type {
   AnyTemporalKey,
   CalendarSlot
 } from './internaltypes';
+import type { CalendarFieldDescriptor } from './ecmascript';
 
 const ArrayIncludes = Array.prototype.includes;
 const ArrayPrototypePush = Array.prototype.push;
+const ArrayPrototypeSort = Array.prototype.sort;
 const IntlDateTimeFormat = globalThis.Intl.DateTimeFormat;
-const ArraySort = Array.prototype.sort;
 const MathAbs = Math.abs;
 const MathFloor = Math.floor;
 const ObjectCreate = Object.create;
 const ObjectEntries = Object.entries;
 const OriginalSet = Set;
 const ReflectOwnKeys = Reflect.ownKeys;
 const SetPrototypeAdd = Set.prototype.add;
-const SetPrototypeValues = Set.prototype.values;
+
+function arrayFromSet<T>(src: Set<T>): T[] {
+  return [...src];
+}
 
 /**
  * Shape of internal implementation of each built-in calendar. Note that
@@ -127,21 +131,16 @@ const impl: CalendarImplementations = {} as unknown as CalendarImplementations;
  * 6. Call the corresponding method in the implementation object.
  */
 export class Calendar implements Temporal.Calendar {
-  constructor(idParam: Params['constructor'][0]) {
-    // Note: if the argument is not passed, IsBuiltinCalendar("undefined") will fail. This check
-    //       exists only to improve the error message.
-    if (arguments.length < 1) {
-      throw new RangeError('missing argument: id is required');
-    }
+  constructor(id: Params['constructor'][0]) {
+    const stringId = ES.RequireString(id);
 
-    const id = ES.ToString(idParam);
-    if (!ES.IsBuiltinCalendar(id)) throw new RangeError(`invalid calendar identifier ${id}`);
+    if (!ES.IsBuiltinCalendar(stringId)) throw new RangeError(`invalid calendar identifier ${stringId}`);
     CreateSlots(this);
-    SetSlot(this, CALENDAR_ID, ES.ASCIILowercase(id));
+    SetSlot(this, CALENDAR_ID, ES.ASCIILowercase(stringId));
 
     if (DEBUG) {
       Object.defineProperty(this, '_repr_', {
-        value: `${this[Symbol.toStringTag]} <${id}>`,
+        value: `${this[Symbol.toStringTag]} <${stringId}>`,
         writable: false,
         enumerable: false,
         configurable: false
@@ -185,18 +184,7 @@ export class Calendar implements Temporal.Calendar {
   fields(fields: Params['fields'][0]): Return['fields'] {
     if (!ES.IsTemporalCalendar(this)) throw new TypeError('invalid receiver');
     const fieldsArray = [] as string[];
-    const allowed = new Set([
-      'year',
-      'month',
-      'monthCode',
-      'day',
-      'hour',
-      'minute',
-      'second',
-      'millisecond',
-      'microsecond',
-      'nanosecond'
-    ]);
+    const allowed = new OriginalSet<string>(['year', 'month', 'monthCode', 'day']);
     for (const name of fields) {
       if (typeof name !== 'string') throw new TypeError('invalid fields');
       if (!allowed.has(name)) throw new RangeError(`invalid field name ${name}`);
@@ -425,18 +413,17 @@ impl['iso8601'] = {
     if (fields.month !== undefined && fields.year === undefined && fields.monthCode === undefined) {
       throw new TypeError('either year or monthCode required with month');
     }
-    const useYear = fields.monthCode === undefined;
     const referenceISOYear = 1972;
     fields = resolveNonLunisolarMonth(fields);
     let { month, day, year } = fields;
-    ({ month, day } = ES.RegulateISODate(useYear ? year : referenceISOYear, month, day, overflow));
+    ({ month, day } = ES.RegulateISODate(year !== undefined ? year : referenceISOYear, month, day, overflow));
     return ES.CreateTemporalMonthDay(month, day, calendarSlotValue, referenceISOYear);
   },
   fields(fields) {
     return fields;
   },
   fieldKeysToIgnore(keys) {
-    const result = new OriginalSet();
+    const result = new OriginalSet<string>();
     for (let ix = 0; ix < keys.length; ix++) {
       const key = keys[ix];
       ES.Call(SetPrototypeAdd, result, [key]);
@@ -446,7 +433,7 @@ impl['iso8601'] = {
         ES.Call(SetPrototypeAdd, result, ['month']);
       }
     }
-    return [...ES.Call(SetPrototypeValues, result, [])];
+    return arrayFromSet(result);
   },
   dateAdd(date, years, months, weeks, days, overflow, calendarSlotValue) {
     let year = GetSlot(date, ISO_YEAR);
@@ -1799,12 +1786,14 @@ function adjustEras(erasParam: InputEra[]): { eras: Era[]; anchorEra: Era } {
   // Ensure that the latest epoch is first in the array. This lets us try to
   // match eras in index order, with the last era getting the remaining older
   // years. Any reverse-signed era must be at the end.
-  ArraySort.call(eras, (e1, e2) => {
-    if (e1.reverseOf) return 1;
-    if (e2.reverseOf) return -1;
-    if (!e1.isoEpoch || !e2.isoEpoch) throw new RangeError('Invalid era data: missing ISO epoch');
-    return e2.isoEpoch.year - e1.isoEpoch.year;
-  });
+  ES.Call(ArrayPrototypeSort, eras, [
+    (e1, e2) => {
+      if (e1.reverseOf) return 1;
+      if (e2.reverseOf) return -1;
+      if (!e1.isoEpoch || !e2.isoEpoch) throw new RangeError('Invalid era data: missing ISO epoch');
+      return e2.isoEpoch.year - e1.isoEpoch.year;
+    }
+  ]);
 
   // If there's a reversed era, then the one before it must be the era that's
   // being reversed.
@@ -2326,14 +2315,25 @@ class DangiHelper extends ChineseBaseHelper {
  */
 class NonIsoCalendar implements CalendarImpl {
   constructor(private readonly helper: HelperBase) {}
+  CalendarFieldDescriptors(type: 'date' | 'month-day' | 'year-month'): CalendarFieldDescriptor[] {
+    let fieldDescriptors = [] as CalendarFieldDescriptor[];
+    if (type !== 'month-day') {
+      fieldDescriptors = [
+        { property: 'era', conversion: ES.ToString, required: false },
+        { property: 'eraYear', conversion: ES.ToIntegerOrInfinity, required: false }
+      ];
+    }
+    return fieldDescriptors;
+  }
   dateFromFields(
     fieldsParam: Params['dateFromFields'][0],
     options: NonNullable<Params['dateFromFields'][1]>,
     calendarSlotValue: string
   ): Temporal.PlainDate {
     const cache = new OneObjectCache();
-    const fieldNames = this.fields(['day', 'month', 'monthCode', 'year']) as AnyTemporalKey[];
-    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, []);
+    const fieldNames = ['day', 'month', 'monthCode', 'year'] as AnyTemporalKey[];
+    const extraFieldDescriptors = this.CalendarFieldDescriptors('date');
+    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, [], extraFieldDescriptors);
     const overflow = ES.ToTemporalOverflow(options);
     const { year, month, day } = this.helper.calendarToIsoDate(fields, overflow, cache);
     const result = ES.CreateTemporalDate(year, month, day, calendarSlotValue);
@@ -2346,8 +2346,9 @@ class NonIsoCalendar implements CalendarImpl {
     calendarSlotValue: CalendarSlot
   ): Temporal.PlainYearMonth {
     const cache = new OneObjectCache();
-    const fieldNames = this.fields(['month', 'monthCode', 'year']) as AnyTemporalKey[];
-    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, []);
+    const fieldNames = ['month', 'monthCode', 'year'] as AnyTemporalKey[];
+    const extraFieldDescriptors = this.CalendarFieldDescriptors('year-month');
+    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, [], extraFieldDescriptors);
     const overflow = ES.ToTemporalOverflow(options);
     const { year, month, day } = this.helper.calendarToIsoDate({ ...fields, day: 1 }, overflow, cache);
     const result = ES.CreateTemporalYearMonth(year, month, calendarSlotValue, /* referenceISODay = */ day);
@@ -2362,24 +2363,29 @@ class NonIsoCalendar implements CalendarImpl {
     const cache = new OneObjectCache();
     // For lunisolar calendars, either `monthCode` or `year` must be provided
     // because `month` is ambiguous without a year or a code.
-    const fieldNames = this.fields(['day', 'month', 'monthCode', 'year']) as AnyTemporalKey[];
-    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, []);
+    const fieldNames = ['day', 'month', 'monthCode', 'year'] as AnyTemporalKey[];
+    const extraFieldDescriptors = this.CalendarFieldDescriptors('date');
+    const fields = ES.PrepareTemporalFields(fieldsParam, fieldNames, [], extraFieldDescriptors);
     const overflow = ES.ToTemporalOverflow(options);
     const { year, month, day } = this.helper.monthDayFromFields(fields, overflow, cache);
     // `year` is a reference year where this month/day exists in this calendar
     const result = ES.CreateTemporalMonthDay(month, day, calendarSlotValue, /* referenceISOYear = */ year);
     cache.setObject(result);
     return result;
   }
-  fields(fieldsParam: string[]): string[] {
-    let fields = fieldsParam;
-    if (ArrayIncludes.call(fields, 'year')) fields = [...fields, 'era', 'eraYear'];
+  fields(fields: string[]): string[] {
+    // Note that `fields` is a new array created by the caller of this method,
+    // not the original input passed by the original caller. So it's safe to
+    // mutate it here because the mutation is not observable.
+    if (ES.Call(ArrayIncludes, fields, ['year'])) {
+      ES.Call(ArrayPrototypePush, fields, ['era', 'eraYear']);
+    }
     return fields;
   }
   fieldKeysToIgnore(
     keys: Exclude<keyof Temporal.PlainDateLike, 'calendar'>[]
   ): Exclude<keyof Temporal.PlainDateLike, 'calendar'>[] {
-    const result = new OriginalSet();
+    const result = new OriginalSet<(typeof keys)[number]>();
     for (let ix = 0; ix < keys.length; ix++) {
       const key = keys[ix];
       ES.Call(SetPrototypeAdd, result, [key]);
@@ -2419,7 +2425,7 @@ class NonIsoCalendar implements CalendarImpl {
           break;
       }
     }
-    return [...ES.Call(SetPrototypeValues, result, [])];
+    return arrayFromSet(result);
   }
   dateAdd(
     date: Temporal.PlainDate,