Polyfill: fix Chinese/Dangi calendar at extreme date ranges (#3277)

* Polyfill: fix Chinese/Dangi calendar at extreme date ranges

Use Metonic cycle (19-year) offset to shift extreme ISO years into
ICU4C's safe range before calling Intl.DateTimeFormat, then adjust
the calendar year back. Fixes #3081.

* Add runtime detection of ICU-23286 bug in Chinese/Dangi calendar

* Add chinese and dangi to thorough calendar day math tests

* Polyfill: make chineseMetonicOffset a method on helperChinese

Move the standalone chineseMetonicOffset function into helperChinese as
a metonicOffset method, using `this` instead of the `helper` parameter.
helperDangi inherits it via ObjectAssign spread.

Thanks to ptomato for the suggestion.

Author: jessealama

polyfill/lib/calendar.mjs

@@ -27,6 +27,7 @@ import {
   MapPrototypeSet,
   MathAbs,
   MathFloor,
+  MathRound,
   MathTrunc,
   MathMax,
   MathSign,
@@ -1913,9 +1914,51 @@ const helperJapanese = ObjectAssign(
   }
 );
 
+// ICU4C's Chinese/Dangi calendar fails for ISO years outside ~-29688 to +70368.
+// Work around this using the Metonic cycle (see also Hebrew cycleInfo above):
+// shift by a multiple of 19 years into the safe range, then adjust back.
+const CHINESE_ICU_SAFE_LOW = -29000;
+const CHINESE_ICU_SAFE_HIGH = 70000;
+
 const helperChinese = ObjectAssign({}, nonIsoHelperBase, {
   id: 'chinese',
   calendarType: 'lunisolar',
+  isVulnerableTo70000Bug() {
+    // https://unicode-org.atlassian.net/browse/ICU-23286
+    if (this.vulnerableTo70000Bug === undefined) {
+      const formatter = this.getFormatter();
+      try {
+        Call(IntlDateTimeFormatPrototypeFormatToParts, formatter, [2146851043199999 + 1]);
+        this.vulnerableTo70000Bug = false;
+      } catch {
+        this.vulnerableTo70000Bug = true;
+      }
+    }
+    return this.vulnerableTo70000Bug;
+  },
+  metonicOffset(year) {
+    if (!this.isVulnerableTo70000Bug()) return 0;
+    if (year >= CHINESE_ICU_SAFE_LOW && year <= CHINESE_ICU_SAFE_HIGH) return 0;
+    return MathRound((year - 2000) / 19) * 19;
+  },
+  isoToCalendarDate(isoDate, cache) {
+    const offset = this.metonicOffset(isoDate.year);
+    if (offset === 0) {
+      return nonIsoHelperBase.isoToCalendarDate.call(this, isoDate, cache);
+    }
+    const safeIsoDate = { ...isoDate, year: isoDate.year - offset };
+    const result = nonIsoHelperBase.isoToCalendarDate.call(this, safeIsoDate, cache);
+    const adjusted = { ...result, year: result.year + offset };
+    // Cache both directions with the original (not shifted) date keys
+    const key = OneObjectCache.generateISOToCalendarKey(isoDate);
+    cache.set(key, adjusted);
+    const cacheReverse = (overflow) => {
+      const keyReverse = OneObjectCache.generateCalendarToISOKey(adjusted, overflow);
+      cache.set(keyReverse, isoDate);
+    };
+    Call(ArrayPrototypeForEach, ['constrain', 'reject'], [cacheReverse]);
+    return adjusted;
+  },
   inLeapYear(calendarDate, cache) {
     return this.getMonthList(calendarDate.year, cache).monthsInYear === 13;
   },
@@ -1986,6 +2029,9 @@ const helperChinese = ObjectAssign({}, nonIsoHelperBase, {
     const cached = cache.get(key);
     if (cached) return cached;
 
+    const offset = this.metonicOffset(calendarYear);
+    const effectiveYear = calendarYear - offset;
+
     // Reuse the same local object for calendar-specific results, starting with
     // a date close to Chinese New Year. Feb 17 will either be in the new year
     // or near the end of the previous year's final month.
@@ -1994,7 +2040,7 @@ const helperChinese = ObjectAssign({}, nonIsoHelperBase, {
     const dateTimeFormat = this.getFormatter();
     const updateCalendarFields = () => {
       // Abuse GetUTCEpochMilliseconds for automatic rebalancing.
-      const isoNumbers = { year: calendarYear, month: 2, day: daysPastJan31 };
+      const isoNumbers = { year: effectiveYear, month: 2, day: daysPastJan31 };
       const ms = ES.GetUTCEpochMilliseconds(isoNumbers, midnightTimeRecord);
       const fieldEntries = Call(IntlDateTimeFormatPrototypeFormatToParts, dateTimeFormat, [ms]);
       for (let i = 0; i < fieldEntries.length; i++) {
@@ -2047,7 +2093,7 @@ const helperChinese = ObjectAssign({}, nonIsoHelperBase, {
       }
       oldDay = day;
 
-      if (relatedYear !== calendarYear) break;
+      if (relatedYear !== effectiveYear) break;
 
       monthList[monthIndex] = { monthCode };
       monthList[monthCode] = monthIndex++;

polyfill/lib/primordials.mjs

@@ -111,6 +111,7 @@ export const {
   log10: MathLog10,
   max: MathMax,
   min: MathMin,
+  round: MathRound,
   sign: MathSign,
   trunc: MathTrunc
 } = Math;

polyfill/test/expected-failures.txt

@@ -34,12 +34,8 @@ intl402/Temporal/ZonedDateTime/prototype/daysInYear/basic-chinese.js
 intl402/DateTimeFormat/prototype/resolvedOptions/resolved-calendar-unicode-extensions-and-options.js
 intl402/DateTimeFormat/prototype/resolvedOptions/resolved-numbering-system-unicode-extensions-and-options.js
 
-# ICU4C internal error in extreme dates in chinese/dangi calendars
-intl402/Temporal/PlainDate/from/extreme-dates.js
-intl402/Temporal/PlainDateTime/from/extreme-dates.js
-# Also fails because of https://github.com/tc39/proposal-temporal/issues/3251
+# https://github.com/tc39/proposal-temporal/issues/3251
 intl402/Temporal/PlainYearMonth/from/extreme-dates.js
-intl402/Temporal/ZonedDateTime/from/extreme-dates.js
 
 # https://issues.chromium.org/issues/481634945
 intl402/DateTimeFormat/prototype/formatToParts/era.js

polyfill/test/thorough/calendardaymath.mjs

@@ -8,12 +8,11 @@ import {
 } from './support.mjs';
 
 const largestUnits = [{ largestUnit: 'weeks' }, { largestUnit: 'days' }];
-// 'chinese' and 'dangi' are temporarily omitted because there are some dates
-// that the current version of ICU4C can't handle well enough to calculate the
-// snapshots
 const calendars = [
   'buddhist',
+  'chinese',
   'coptic',
+  'dangi',
   'ethioaa',
   'ethiopic',
   'gregory',