Move all ZonedDateTime arithmetic outside of it

Author: dkhalanskyjb

core/native/src/Instant.kt

@@ -10,7 +10,6 @@ package kotlinx.datetime
 
 import kotlinx.cinterop.*
 import kotlinx.datetime.internal.*
-import kotlinx.datetime.optional
 import kotlinx.datetime.serializers.InstantIso8601Serializer
 import kotlinx.serialization.Serializable
 import platform.posix.*
@@ -264,7 +263,7 @@ private fun Instant.toZonedDateTimeFailing(zone: TimeZone): ZonedDateTime = try
  */
 private fun Instant.toZonedDateTime(zone: TimeZone): ZonedDateTime {
     val currentOffset = zone.offsetAt(this)
-    return ZonedDateTime(toLocalDateTimeImpl(currentOffset), zone, currentOffset)
+    return ZonedDateTime(toLocalDateTimeImpl(currentOffset), currentOffset)
 }
 
 /** Check that [Instant] fits in [ZonedDateTime].
@@ -277,8 +276,8 @@ private fun Instant.check(zone: TimeZone): Instant = [email protected] {
 public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Instant = try {
     with(period) {
         val withDate = toZonedDateTimeFailing(timeZone)
-            .run { if (totalMonths != 0) plus(totalMonths, DateTimeUnit.MONTH) else this }
-            .run { if (days != 0) plus(days, DateTimeUnit.DAY) else this }
+            .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()
             .run { if (totalNanoseconds != 0L) plus(0, totalNanoseconds).check(timeZone) else this }
     }.check(timeZone)
@@ -300,7 +299,11 @@ 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")
-            toZonedDateTimeFailing(timeZone).plus(value.toInt(), unit).toInstant()
+            val toZonedDateTimeFailing = toZonedDateTimeFailing(timeZone)
+            timeZone.atZone(
+                toZonedDateTimeFailing.dateTime.plus(value.toInt(), unit),
+                toZonedDateTimeFailing.offset
+            ).toInstant()
         }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
@@ -326,11 +329,20 @@ public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateT
     var thisLdt = toZonedDateTimeFailing(timeZone)
     val otherLdt = other.toZonedDateTimeFailing(timeZone)
 
-    val months = thisLdt.until(otherLdt, DateTimeUnit.MONTH).toInt() // `until` on dates never fails
-    thisLdt = thisLdt.plus(months, DateTimeUnit.MONTH) // won't throw: thisLdt + months <= otherLdt, which is known to be valid
-    val days = thisLdt.until(otherLdt, DateTimeUnit.DAY).toInt() // `until` on dates never fails
-    thisLdt = thisLdt.plus(days, DateTimeUnit.DAY) // won't throw: thisLdt + days <= otherLdt
-    val nanoseconds = thisLdt.until(otherLdt, DateTimeUnit.NANOSECOND) // |otherLdt - thisLdt| < 24h
+    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
 
     return buildDateTimePeriod(months, days, nanoseconds)
 }

core/native/src/TimeZone.kt

@@ -113,7 +113,7 @@ 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, this, offset)
+        ZonedDateTime(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

@@ -8,67 +8,20 @@
 
 package kotlinx.datetime
 
-internal class ZonedDateTime(val dateTime: LocalDateTime, private val zone: TimeZone, val offset: UtcOffset) {
-    /**
-     * @throws IllegalArgumentException if the result exceeds the boundaries
-     * @throws ArithmeticException if arithmetic overflow occurs
-     */
-    internal fun plus(value: Int, unit: DateTimeUnit.DateBased): ZonedDateTime = dateTime.plus(value, unit).resolve()
-
-    // Never throws in practice
-    private fun LocalDateTime.resolve(): ZonedDateTime =
-        // workaround for https://github.com/Kotlin/kotlinx-datetime/issues/51
-        if (this@resolve.toInstant(offset).toLocalDateTime(zone) == this@resolve) {
-            // this LocalDateTime is valid in these timezone and offset.
-            ZonedDateTime(this, zone, offset)
-        } else {
-            // this LDT does need proper resolving, as the instant that it would map to given the preferred offset
-            // is is mapped to another LDT.
-            zone.atZone(this, offset)
-        }
-
+internal class ZonedDateTime(val dateTime: LocalDateTime, val offset: UtcOffset) {
     override fun equals(other: Any?): Boolean =
         this === other || other is ZonedDateTime &&
-            dateTime == other.dateTime && offset == other.offset && zone == other.zone
+            dateTime == other.dateTime && offset == other.offset
 
     override fun hashCode(): Int {
-        return dateTime.hashCode() xor offset.hashCode() xor zone.hashCode().rotateLeft(3)
+        return dateTime.hashCode() xor offset.hashCode()
     }
 
     override fun toString(): String {
-        var str = dateTime.toString() + offset.toString()
-        if (zone !is FixedOffsetTimeZone || offset !== zone.offset) {
-            str += "[$zone]"
-        }
+        val str = dateTime.toString() + offset.toString()
         return str
     }
 }
 
 internal fun ZonedDateTime.toInstant(): Instant =
     Instant(dateTime.toEpochSecond(offset), dateTime.nanosecond)
-
-
-// org.threeten.bp.ZonedDateTime#until
-// This version is simplified and to be used ONLY in case you know the timezones are equal!
-/**
- * @throws ArithmeticException on arithmetic overflow
- * @throws DateTimeArithmeticException if setting [other] to the offset of [this] leads to exceeding boundaries of
- * [LocalDateTime].
- */
-
-internal fun ZonedDateTime.until(other: ZonedDateTime, unit: DateTimeUnit): Long =
-    when (unit) {
-        // if the time unit is date-based, the offsets are disregarded and only the dates and times are compared.
-        is DateTimeUnit.DateBased -> dateTime.until(other.dateTime, unit).toLong()
-        // if the time unit is not date-based, we need to make sure that [other] is at the same offset as [this].
-        is DateTimeUnit.TimeBased -> {
-            val offsetDiff = offset.totalSeconds - other.offset.totalSeconds
-            val otherLdtAdjusted = try {
-                other.dateTime.plusSeconds(offsetDiff)
-            } catch (e: IllegalArgumentException) {
-                throw DateTimeArithmeticException(
-                    "Unable to find difference between date-times, as one of them overflowed")
-            }
-            dateTime.until(otherLdtAdjusted, unit)
-        }
-    }

core/native/src/internal/RegionTimeZone.kt

@@ -29,10 +29,10 @@ internal class RegionTimeZone(private val tzid: TimeZoneRules, override val id:
 
     override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime =
         when (val info = tzid.infoAtDatetime(dateTime)) {
-            is OffsetInfo.Regular -> ZonedDateTime(dateTime, this, info.offset)
+            is OffsetInfo.Regular -> ZonedDateTime(dateTime, info.offset)
             is OffsetInfo.Gap -> {
                 try {
-                    ZonedDateTime(dateTime.plusSeconds(info.transitionDurationSeconds), this, info.offsetAfter)
+                    ZonedDateTime(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,8 +41,10 @@ internal class RegionTimeZone(private val tzid: TimeZoneRules, override val id:
                 }
             }
 
-            is OffsetInfo.Overlap -> ZonedDateTime(dateTime, this,
-                if (info.offsetAfter == preferred) info.offsetAfter else info.offsetBefore)
+            is OffsetInfo.Overlap -> ZonedDateTime(
+                dateTime,
+                if (info.offsetAfter == preferred) info.offsetAfter else info.offsetBefore
+            )
         }
 
     override fun offsetAtImpl(instant: Instant): UtcOffset = tzid.infoAtInstant(instant)

core/native/test/ThreeTenBpTimeZoneTest.kt

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