Rebase: ISO Date-Time Record refactoring

lib/calendar.ts

@@ -134,9 +134,15 @@ function calendarDateWeekOfYear(
   return { week: woy, year: yow };
 }
 
-function ISODateSurpasses(sign: -1 | 0 | 1, y1: number, m1: number, d1: number, y2: number, m2: number, d2: number) {
-  const cmp = ES.CompareISODate(y1, m1, d1, y2, m2, d2);
-  return sign * cmp === 1;
+function ISODateSurpasses(sign: -1 | 0 | 1, y1: number, m1: number, d1: number, isoDate2: ISODate) {
+  if (y1 !== isoDate2.year) {
+    if (sign * (y1 - isoDate2.year) > 0) return true;
+  } else if (m1 !== isoDate2.month) {
+    if (sign * (m1 - isoDate2.month) > 0) return true;
+  } else if (d1 !== isoDate2.day) {
+    if (sign * (d1 - isoDate2.day) > 0) return true;
+  }
+  return false;
 }
 
 interface CalendarDateRecord {
@@ -260,7 +266,7 @@ impl['iso8601'] = {
     return ES.BalanceISODate(year, month, day);
   },
   dateUntil(one, two, largestUnit) {
-    const sign = -ES.CompareISODate(one.year, one.month, one.day, two.year, two.month, two.day);
+    const sign = -ES.CompareISODate(one, two);
     if (sign === 0) return { years: 0, months: 0, weeks: 0, days: 0 };
     ES.uncheckedAssertNarrowedType<-1 | 1>(sign, "the - operator's return type is number");
 
@@ -273,15 +279,15 @@ impl['iso8601'] = {
       let candidateYears = two.year - one.year;
       if (candidateYears !== 0) candidateYears -= sign;
       // loops at most twice
-      while (!ISODateSurpasses(sign, one.year + candidateYears, one.month, one.day, two.year, two.month, two.day)) {
+      while (!ISODateSurpasses(sign, one.year + candidateYears, one.month, one.day, two)) {
         years = candidateYears;
         candidateYears += sign;
       }
 
       let candidateMonths = sign;
       intermediate = ES.BalanceISOYearMonth(one.year + years, one.month + candidateMonths);
       // loops at most 12 times
-      while (!ISODateSurpasses(sign, intermediate.year, intermediate.month, one.day, two.year, two.month, two.day)) {
+      while (!ISODateSurpasses(sign, intermediate.year, intermediate.month, one.day, two)) {
         months = candidateMonths;
         candidateMonths += sign;
         intermediate = ES.BalanceISOYearMonth(intermediate.year, intermediate.month + sign);
@@ -2336,8 +2342,10 @@ class NonIsoCalendar implements CalendarImpl {
     const added = this.helper.addCalendar(calendarDate, { years, months, weeks, days }, overflow, cache);
     const isoAdded = this.helper.calendarToIsoDate(added, 'constrain', cache);
     // The new object's cache starts with the cache of the old object
-    const newCache = new OneObjectCache(cache);
-    newCache.setObject(isoAdded);
+    if (!OneObjectCache.getCacheForObject(isoAdded)) {
+      const newCache = new OneObjectCache(cache);
+      newCache.setObject(isoAdded);
+    }
     return isoAdded;
   }
   dateUntil(one: ISODate, two: ISODate, largestUnit: Temporal.DateUnit) {

lib/duration.ts

@@ -33,6 +33,7 @@ import {
   EPOCHNANOSECONDS,
   CreateSlots,
   GetSlot,
+  ISO_DATE,
   SetSlot,
   TIME_ZONE
 } from './slots';
@@ -250,33 +251,19 @@ export class Duration implements Temporal.Duration {
 
     if (plainRelativeTo) {
       let duration = ES.NormalizeDurationWith24HourDays(this);
-      const targetTime = ES.AddTime(0, 0, 0, 0, 0, 0, duration.norm);
+      const targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.norm);
 
       // Delegate the date part addition to the calendar
-      const isoRelativeToDate = ES.TemporalObjectToISODateRecord(plainRelativeTo);
+      const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
       const calendar = GetSlot(plainRelativeTo, CALENDAR);
       const dateDuration = ES.AdjustDateDurationRecord(duration.date, targetTime.deltaDays);
       const targetDate = ES.CalendarDateAdd(calendar, isoRelativeToDate, dateDuration, 'constrain');
 
+      const isoDateTime = ES.CombineISODateAndTimeRecord(isoRelativeToDate, ES.MidnightTimeRecord());
+      const targetDateTime = ES.CombineISODateAndTimeRecord(targetDate, targetTime);
       duration = ES.DifferencePlainDateTimeWithRounding(
-        isoRelativeToDate.year,
-        isoRelativeToDate.month,
-        isoRelativeToDate.day,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        targetDate.year,
-        targetDate.month,
-        targetDate.day,
-        targetTime.hour,
-        targetTime.minute,
-        targetTime.second,
-        targetTime.millisecond,
-        targetTime.microsecond,
-        targetTime.nanosecond,
+        isoDateTime,
+        targetDateTime,
         calendar,
         largestUnit,
         roundingIncrement,
@@ -320,36 +307,17 @@ export class Duration implements Temporal.Duration {
 
     if (plainRelativeTo) {
       const duration = ES.NormalizeDurationWith24HourDays(this);
-      let targetTime = ES.AddTime(0, 0, 0, 0, 0, 0, duration.norm);
+      let targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.norm);
 
       // Delegate the date part addition to the calendar
-      const isoRelativeToDate = ES.TemporalObjectToISODateRecord(plainRelativeTo);
+      const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
       const calendar = GetSlot(plainRelativeTo, CALENDAR);
       const dateDuration = ES.AdjustDateDurationRecord(duration.date, targetTime.deltaDays);
       const targetDate = ES.CalendarDateAdd(calendar, isoRelativeToDate, dateDuration, 'constrain');
 
-      return ES.DifferencePlainDateTimeWithTotal(
-        isoRelativeToDate.year,
-        isoRelativeToDate.month,
-        isoRelativeToDate.day,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        targetDate.year,
-        targetDate.month,
-        targetDate.day,
-        targetTime.hour,
-        targetTime.minute,
-        targetTime.second,
-        targetTime.millisecond,
-        targetTime.microsecond,
-        targetTime.nanosecond,
-        calendar,
-        unit
-      );
+      const isoDateTime = ES.CombineISODateAndTimeRecord(isoRelativeToDate, ES.MidnightTimeRecord());
+      const targetDateTime = ES.CombineISODateAndTimeRecord(targetDate, targetTime);
+      return ES.DifferencePlainDateTimeWithTotal(isoDateTime, targetDateTime, calendar, unit);
     }
 
     // No reference date to calculate difference relative to