Remove all commonKotlin ZonedDateTime arithmetic logic

Author: dkhalanskyjb

core/commonJs/src/internal/Platform.kt

@@ -110,7 +110,7 @@ private object SystemTimeZone: TimeZone() {
                 offsetInMinutesBeforePossibleTransition * SECONDS_PER_MINUTE * MILLIS_PER_ONE
         val offsetInMinutesAfterPossibleTransition = Date(epochMilliSystemZone.toDouble()).getTimezoneOffset().toInt()
         val offset = UtcOffset(minutes = -offsetInMinutesAfterPossibleTransition)
-        return ZonedDateTime(dateTime, this, offset)
+        return ZonedDateTime(dateTime, offset)
     }
 
     override fun equals(other: Any?): Boolean = other === this

core/commonKotlin/src/Instant.kt

@@ -175,7 +175,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].
@@ -188,8 +188,8 @@ private fun Instant.check(zone: TimeZone): Instant = this@check.also {
 public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Instant = try {
     with(period) {
         val withDate = toZonedDateTimeFailing(timeZone)
-            .run { if (totalMonths != 0L) plus(totalMonths, DateTimeUnit.MONTH) else this }
-            .run { if (days != 0) plus(days.toLong(), DateTimeUnit.DAY) else this }
+            .run { if (totalMonths != 0L) 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)
@@ -208,8 +208,13 @@ public actual fun Instant.minus(value: Int, unit: DateTimeUnit, timeZone: TimeZo
     plus(-value.toLong(), unit, timeZone)
 public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZone): Instant = try {
     when (unit) {
-        is DateTimeUnit.DateBased ->
-            toZonedDateTimeFailing(timeZone).plus(value, unit).toInstant()
+        is DateTimeUnit.DateBased -> {
+            val toZonedDateTimeFailing = toZonedDateTimeFailing(timeZone)
+            timeZone.atZone(
+                toZonedDateTimeFailing.dateTime.plus(value, unit),
+                toZonedDateTimeFailing.offset
+            ).toInstant()
+        }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
     }
@@ -234,11 +239,19 @@ 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) // `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) // `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) // `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) // `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.toInt(), nanoseconds)
 }
@@ -277,3 +290,9 @@ private val ISO_DATE_TIME_OFFSET_WITH_TRAILING_ZEROS = DateTimeComponents.Format
         outputSecond = WhenToOutput.IF_NONZERO
     )
 }
+
+private fun LocalDateTime.plus(value: Long, unit: DateTimeUnit.DateBased) =
+    date.plus(value, unit).atTime(time)
+
+private fun LocalDateTime.plus(value: Int, unit: DateTimeUnit.DateBased) =
+    date.plus(value, unit).atTime(time)

core/commonKotlin/src/TimeZone.kt

@@ -119,7 +119,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/commonKotlin/src/ZonedDateTime.kt

@@ -8,68 +8,21 @@
 
 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: Long, unit: DateTimeUnit.DateBased): ZonedDateTime =
-        dateTime.date.plus(value, unit).atTime(dateTime.time).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)
-        // 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/commonKotlin/src/internal/RegionTimeZone.kt

@@ -20,10 +20,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",
@@ -32,8 +32,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/commonKotlin/test/ThreeTenBpTimeZoneTest.kt

@@ -40,8 +40,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))
     }
 
 }