Simplify the code for Instant arithmetics

Author: dkhalanskyjb

core/native/src/Instant.kt

@@ -252,33 +252,39 @@ public actual class Instant internal constructor(public actual val epochSeconds:
 
 }
 
-private fun Instant.toZonedDateTimeFailing(zone: TimeZone): ZonedDateTime = try {
-    toZonedDateTime(zone)
+private fun Instant.toLocalDateTimeFailing(offset: UtcOffset): LocalDateTime = try {
+    toLocalDateTimeImpl(offset)
 } catch (e: IllegalArgumentException) {
     throw DateTimeArithmeticException("Can not convert instant $this to LocalDateTime to perform computations", e)
 }
 
-/**
- * @throws IllegalArgumentException if the [Instant] exceeds the boundaries of [LocalDateTime]
- */
-private fun Instant.toZonedDateTime(zone: TimeZone): ZonedDateTime {
-    val currentOffset = zone.offsetAt(this)
-    return ZonedDateTime(toLocalDateTimeImpl(currentOffset), currentOffset)
-}
-
-/** Check that [Instant] fits in [ZonedDateTime].
+/** Check that [Instant] fits in [LocalDateTime].
  * This is done on the results of computations for consistency with other platforms.
  */
 private fun Instant.check(zone: TimeZone): Instant = this@check.also {
-    toZonedDateTimeFailing(zone)
+    toLocalDateTimeFailing(offsetIn(zone))
 }
 
 public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Instant = try {
     with(period) {
-        val withDate = toZonedDateTimeFailing(timeZone)
-            .run { if (totalMonths != 0) timeZone.atZone(dateTime.plus(totalMonths, DateTimeUnit.MONTH), offset) else this }
-            .run { if (days != 0) timeZone.atZone(dateTime.plus(days, DateTimeUnit.DAY), offset) else this }
-        withDate.toInstant()
+        val initialOffset = offsetIn(timeZone)
+        val initialLdt = toLocalDateTimeFailing(initialOffset)
+        val offsetAfterMonths: UtcOffset
+        val ldtAfterMonths: LocalDateTime
+        if (totalMonths != 0) {
+            val (ldt, offset) = timeZone.atZone(initialLdt.plus(totalMonths, DateTimeUnit.MONTH), initialOffset)
+            offsetAfterMonths = offset
+            ldtAfterMonths = ldt
+        } else {
+            offsetAfterMonths = initialOffset
+            ldtAfterMonths = initialLdt
+        }
+        val instantAfterMonthsAndDays = if (days != 0) {
+            timeZone.atZone(ldtAfterMonths.plus(days, DateTimeUnit.DAY), offsetAfterMonths).toInstant()
+        } else {
+            ldtAfterMonths.toInstant(offsetAfterMonths)
+        }
+        instantAfterMonthsAndDays
             .run { if (totalNanoseconds != 0L) plus(0, totalNanoseconds).check(timeZone) else this }
     }.check(timeZone)
 } catch (e: ArithmeticException) {
@@ -299,11 +305,9 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
         is DateTimeUnit.DateBased -> {
             if (value < Int.MIN_VALUE || value > Int.MAX_VALUE)
                 throw ArithmeticException("Can't add a Long date-based value, as it would cause an overflow")
-            val toZonedDateTimeFailing = toZonedDateTimeFailing(timeZone)
-            timeZone.atZone(
-                toZonedDateTimeFailing.dateTime.plus(value.toInt(), unit),
-                toZonedDateTimeFailing.offset
-            ).toInstant()
+            val preferredOffset = offsetIn(timeZone)
+            val initialLdt = toLocalDateTimeFailing(preferredOffset)
+            timeZone.atZone(initialLdt.plus(value.toInt(), unit), preferredOffset).toInstant()
         }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
@@ -326,31 +330,23 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit.TimeBased): Insta
     }
 
 public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateTimePeriod {
-    var thisLdt = toZonedDateTimeFailing(timeZone)
-    val otherLdt = other.toZonedDateTimeFailing(timeZone)
-
-    val months =
-        thisLdt.dateTime.until(otherLdt.dateTime, DateTimeUnit.MONTH).toLong().toInt() // `until` on dates never fails
-    thisLdt = timeZone.atZone(
-        thisLdt.dateTime.plus(months, DateTimeUnit.MONTH),
-        thisLdt.offset
-    ) // won't throw: thisLdt + months <= otherLdt, which is known to be valid
-    val days =
-        thisLdt.dateTime.until(otherLdt.dateTime, DateTimeUnit.DAY).toLong().toInt() // `until` on dates never fails
-    thisLdt = timeZone.atZone(
-        thisLdt.dateTime.plus(days, DateTimeUnit.DAY),
-        thisLdt.offset
-    ) // won't throw: thisLdt + days <= otherLdt
-    val nanoseconds =
-        thisLdt.toInstant().until(otherLdt.toInstant(), DateTimeUnit.NANOSECOND) // |otherLdt - thisLdt| < 24h
+    val thisOffset1 = offsetIn(timeZone)
+    val thisLdt1 = toLocalDateTimeFailing(thisOffset1)
+    val otherLdt = other.toLocalDateTimeFailing(other.offsetIn(timeZone))
+
+    val months = thisLdt1.until(otherLdt, DateTimeUnit.MONTH).toLong().toInt() // `until` on dates never fails
+    val (thisLdt2, thisOffset2) = timeZone.atZone(thisLdt1.plus(months, DateTimeUnit.MONTH), thisOffset1) // won't throw: thisLdt + months <= otherLdt, which is known to be valid
+    val days = thisLdt2.until(otherLdt, DateTimeUnit.DAY).toLong().toInt() // `until` on dates never fails
+    val (thisLdt3, thisOffset3) = timeZone.atZone(thisLdt2.plus(days, DateTimeUnit.DAY), thisOffset2) // won't throw: thisLdt + days <= otherLdt
+    val nanoseconds = thisLdt3.toInstant(thisOffset3).until(other, DateTimeUnit.NANOSECOND) // |otherLdt - thisLdt| < 24h
 
     return buildDateTimePeriod(months, days, nanoseconds)
 }
 
 public actual fun Instant.until(other: Instant, unit: DateTimeUnit, timeZone: TimeZone): Long =
     when (unit) {
         is DateTimeUnit.DateBased ->
-            toZonedDateTimeFailing(timeZone).dateTime.until(other.toZonedDateTimeFailing(timeZone).dateTime, unit)
+            toLocalDateTimeFailing(offsetIn(timeZone)).until(other.toLocalDateTimeFailing(other.offsetIn(timeZone)), unit)
                 .toLong()
         is DateTimeUnit.TimeBased -> {
             check(timeZone); other.check(timeZone)

core/native/src/LocalDateTimeWithOffset.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2019-2020 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+/* Based on the ThreeTenBp project.
+ * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ */
+
+package kotlinx.datetime
+
+internal data class LocalDateTimeWithOffset(val dateTime: LocalDateTime, val offset: UtcOffset)
+
+internal fun LocalDateTimeWithOffset.toInstant(): Instant =
+    Instant(dateTime.toEpochSecond(offset), dateTime.nanosecond)

core/native/src/TimeZone.kt

@@ -88,7 +88,7 @@ public actual open class TimeZone internal constructor() {
     internal open fun localDateTimeToInstant(dateTime: LocalDateTime): Instant =
         atZone(dateTime).toInstant()
 
-    internal open fun atZone(dateTime: LocalDateTime, preferred: UtcOffset? = null): ZonedDateTime =
+    internal open fun atZone(dateTime: LocalDateTime, preferred: UtcOffset? = null): LocalDateTimeWithOffset =
         error("Should be overridden")
 
     override fun equals(other: Any?): Boolean =
@@ -112,8 +112,8 @@ public actual class FixedOffsetTimeZone internal constructor(public actual val o
 
     override fun offsetAtImpl(instant: Instant): UtcOffset = offset
 
-    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime =
-        ZonedDateTime(dateTime, offset)
+    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): LocalDateTimeWithOffset =
+        LocalDateTimeWithOffset(dateTime, offset)
 
     override fun instantToLocalDateTime(instant: Instant): LocalDateTime = instant.toLocalDateTime(offset)
     override fun localDateTimeToInstant(dateTime: LocalDateTime): Instant = dateTime.toInstant(offset)

core/native/src/ZonedDateTime.kt

@@ -27,12 +27,12 @@ internal class RegionTimeZone(private val tzid: TimeZoneRules, override val id:
         }
     }
 
-    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime =
+    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): LocalDateTimeWithOffset =
         when (val info = tzid.infoAtDatetime(dateTime)) {
-            is OffsetInfo.Regular -> ZonedDateTime(dateTime, info.offset)
+            is OffsetInfo.Regular -> LocalDateTimeWithOffset(dateTime, info.offset)
             is OffsetInfo.Gap -> {
                 try {
-                    ZonedDateTime(dateTime.plusSeconds(info.transitionDurationSeconds), info.offsetAfter)
+                    LocalDateTimeWithOffset(dateTime.plusSeconds(info.transitionDurationSeconds), info.offsetAfter)
                 } catch (e: IllegalArgumentException) {
                     throw DateTimeArithmeticException(
                         "Overflow whet correcting the date-time to not be in the transition gap",
@@ -41,7 +41,7 @@ internal class RegionTimeZone(private val tzid: TimeZoneRules, override val id:
                 }
             }
 
-            is OffsetInfo.Overlap -> ZonedDateTime(
+            is OffsetInfo.Overlap -> LocalDateTimeWithOffset(
                 dateTime,
                 if (info.offsetAfter == preferred) info.offsetAfter else info.offsetBefore
             )

core/native/src/internal/RegionTimeZone.kt

@@ -41,7 +41,7 @@ class ThreeTenBpTimeZoneTest {
     fun overlappingLocalTime() {
         val t = LocalDateTime(2007, 10, 28, 2, 30, 0, 0)
         val zone = TimeZone.of("Europe/Paris")
-        assertEquals(ZonedDateTime(
+        assertEquals(LocalDateTimeWithOffset(
             LocalDateTime(2007, 10, 28, 2, 30, 0, 0),
             UtcOffset(seconds = 2 * 3600)
         ), zone.atZone(t))