Specialize Instant.until to avoid intermediate result clamping

Author: ilya-g

core/commonMain/src/DateTimeUnit.kt

@@ -13,12 +13,9 @@ sealed class DateTimeUnit {
 
     abstract operator fun times(scalar: Int): DateTimeUnit
 
-    internal abstract val calendarUnit: CalendarUnit
-    internal abstract val calendarScale: Long
-
     class TimeBased(val nanoseconds: Long) : DateTimeUnit() {
-        internal override val calendarUnit: CalendarUnit
-        internal override val calendarScale: Long
+        internal val calendarUnit: CalendarUnit
+        internal val calendarScale: Long
 
         init {
             require(nanoseconds > 0) { "Unit duration must be positive, but was $nanoseconds ns." }
@@ -72,9 +69,6 @@ sealed class DateTimeUnit {
 
             override fun times(scalar: Int): DayBased = DayBased(safeMultiply(days, scalar))
 
-            internal override val calendarUnit: CalendarUnit get() = CalendarUnit.DAY
-            internal override val calendarScale: Long get() = days.toLong()
-
             override fun equals(other: Any?): Boolean =
                     this === other || (other is DayBased && this.days == other.days)
 
@@ -92,9 +86,6 @@ sealed class DateTimeUnit {
 
             override fun times(scalar: Int): MonthBased = MonthBased(safeMultiply(months, scalar))
 
-            internal override val calendarUnit: CalendarUnit get() = CalendarUnit.MONTH
-            internal override val calendarScale: Long get() = months.toLong()
-
             override fun equals(other: Any?): Boolean =
                     this === other || (other is MonthBased && this.months == other.months)
 

core/commonTest/src/InstantTest.kt

@@ -170,10 +170,9 @@ class InstantTest {
         val end = start.plus(300, DateTimeUnit.YEAR, zone)
         val diffNs = start.until(end, unit500ns, zone)
         val diffUs = start.until(end, DateTimeUnit.MICROSECOND, zone)
-        // TODO: avoid clamping/overflowing in intermediate results in JVM
-//        assertEquals(diffUs * 2, diffNs)
+        assertEquals(diffUs * 2, diffNs)
 
-//        assertEquals(end, start.plus(diffNs, unit500ns, zone))
+        assertEquals(end, start.plus(diffNs, unit500ns, zone))
         assertEquals(start, end.plus(-diffUs, DateTimeUnit.MICROSECOND, zone))
     }
 

core/jsMain/src/Instant.kt

@@ -200,31 +200,20 @@ public actual fun Instant.periodUntil(other: Instant, zone: TimeZone): DateTimeP
 }
 
 public actual fun Instant.until(other: Instant, unit: DateTimeUnit, zone: TimeZone): Long = try {
-    when (unit) {
-        is DateTimeUnit.DateBased ->
-            this.value.atZone(zone).until(other.value.atZone(zone), unit.calendarUnit.toChronoUnit()).toLong() / unit.calendarScale
+    val thisZdt = this.value.atZone(zone)
+    val otherZdt = other.value.atZone(zone)
+    when(unit) {
         is DateTimeUnit.TimeBased -> {
-            this.value.atZone(zone)
-            other.value.atZone(zone)
-            try {
-                multiplyAddAndDivide(
-                        (other.value.epochSecond().toDouble() - this.value.epochSecond().toDouble()).toLong(),
-                        NANOS_PER_ONE.toLong(),
-                        (other.nanosecondsOfSecond - this.nanosecondsOfSecond).toLong(),
-                        unit.nanoseconds)
-            } catch (e: ArithmeticException) {
-                if (this < other) Long.MAX_VALUE else Long.MIN_VALUE
-            }
+            multiplyAddAndDivide(other.epochSeconds - epochSeconds,
+                    NANOS_PER_ONE.toLong(),
+                    (other.nanosecondsOfSecond - nanosecondsOfSecond).toLong(),
+                    unit.nanoseconds)
         }
+        is DateTimeUnit.DateBased.DayBased -> (thisZdt.until(otherZdt, ChronoUnit.DAYS).toDouble() / unit.days).toLong()
+        is DateTimeUnit.DateBased.MonthBased -> (thisZdt.until(otherZdt, ChronoUnit.MONTHS).toDouble() / unit.months).toLong()
     }
+} catch (e: ArithmeticException) {
+    if (this < other) Long.MAX_VALUE else Long.MIN_VALUE
 } catch (e: Throwable) {
     if (e.isJodaDateTimeException()) throw DateTimeArithmeticException(e) else throw e
 }
-
-
-private fun CalendarUnit.toChronoUnit(): ChronoUnit = when(this) {
-    CalendarUnit.YEAR -> ChronoUnit.YEARS
-    CalendarUnit.MONTH -> ChronoUnit.MONTHS
-    CalendarUnit.DAY -> ChronoUnit.DAYS
-    else -> error("CalendarUnit $this should not be used")
-}

core/jvmMain/src/Instant.kt

@@ -145,25 +145,22 @@ public actual fun Instant.periodUntil(other: Instant, zone: TimeZone): DateTimeP
     }
 }
 
-public actual fun Instant.until(other: Instant, unit: DateTimeUnit, zone: TimeZone): Long =
-        until(other, unit.calendarUnit.toChronoUnit(), zone.zoneId) / unit.calendarScale
-
-private fun Instant.until(other: Instant, unit: ChronoUnit, zone: ZoneId): Long = try {
-    this.value.atZone(zone).until(other.value.atZone(zone), unit)
+public actual fun Instant.until(other: Instant, unit: DateTimeUnit, zone: TimeZone): Long = try {
+    val thisZdt = this.atZone(zone)
+    val otherZdt = other.atZone(zone)
+    when(unit) {
+        is DateTimeUnit.TimeBased -> {
+            multiplyAddAndDivide(other.epochSeconds - epochSeconds,
+                    NANOS_PER_ONE.toLong(),
+                    (other.nanosecondsOfSecond - nanosecondsOfSecond).toLong(),
+                    unit.nanoseconds)
+        }
+        is DateTimeUnit.DateBased.DayBased -> thisZdt.until(otherZdt, ChronoUnit.DAYS) / unit.days
+        is DateTimeUnit.DateBased.MonthBased -> thisZdt.until(otherZdt, ChronoUnit.MONTHS) / unit.months
+    }
 } catch (e: DateTimeException) {
     throw DateTimeArithmeticException(e)
 } catch (e: ArithmeticException) {
     if (this.value < other.value) Long.MAX_VALUE else Long.MIN_VALUE
 }
 
-private fun CalendarUnit.toChronoUnit(): ChronoUnit = when(this) {
-    CalendarUnit.YEAR -> ChronoUnit.YEARS
-    CalendarUnit.MONTH -> ChronoUnit.MONTHS
-    CalendarUnit.DAY -> ChronoUnit.DAYS
-    CalendarUnit.HOUR -> ChronoUnit.HOURS
-    CalendarUnit.MINUTE -> ChronoUnit.MINUTES
-    CalendarUnit.SECOND -> ChronoUnit.SECONDS
-    CalendarUnit.MILLISECOND -> ChronoUnit.MILLIS
-    CalendarUnit.MICROSECOND -> ChronoUnit.MICROS
-    CalendarUnit.NANOSECOND -> ChronoUnit.NANOS
-}