Remove ZonedDateTime from the Native implementation

Author: dkhalanskyjb

core/commonJs/src/internal/Platform.kt

@@ -96,21 +96,21 @@ private object SystemTimeZone: TimeZone() {
 
     /* https://github.com/js-joda/js-joda/blob/8c1a7448db92ca014417346049fb64b55f7b1ac1/packages/core/src/LocalDate.js#L1404-L1416 +
     * https://github.com/js-joda/js-joda/blob/8c1a7448db92ca014417346049fb64b55f7b1ac1/packages/core/src/zone/SystemDefaultZoneRules.js#L69-L71 */
-    override fun atStartOfDay(date: LocalDate): Instant = atZone(date.atTime(LocalTime.MIN)).toInstant()
+    override fun atStartOfDay(date: LocalDate): Instant = localDateTimeToInstant(date.atTime(LocalTime.MIN))
 
     /* https://github.com/js-joda/js-joda/blob/8c1a7448db92ca014417346049fb64b55f7b1ac1/packages/core/src/zone/SystemDefaultZoneRules.js#L21-L24 */
     override fun offsetAtImpl(instant: Instant): UtcOffset =
         UtcOffset(minutes = -Date(instant.toEpochMilliseconds().toDouble()).getTimezoneOffset().toInt())
 
     /* https://github.com/js-joda/js-joda/blob/8c1a7448db92ca014417346049fb64b55f7b1ac1/packages/core/src/zone/SystemDefaultZoneRules.js#L49-L55 */
-    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): LocalDateTimeWithOffset {
+    override fun localDateTimeToInstant(dateTime: LocalDateTime, preferred: UtcOffset?): Instant {
         val epochMilli = dateTime.toInstant(UTC).toEpochMilliseconds()
         val offsetInMinutesBeforePossibleTransition = Date(epochMilli.toDouble()).getTimezoneOffset().toInt()
         val epochMilliSystemZone = epochMilli +
                 offsetInMinutesBeforePossibleTransition * SECONDS_PER_MINUTE * MILLIS_PER_ONE
         val offsetInMinutesAfterPossibleTransition = Date(epochMilliSystemZone.toDouble()).getTimezoneOffset().toInt()
         val offset = UtcOffset(minutes = -offsetInMinutesAfterPossibleTransition)
-        return LocalDateTimeWithOffset(dateTime, offset)
+        return dateTime.toInstant(offset)
     }
 
     override fun equals(other: Any?): Boolean = other === this

core/commonKotlin/src/Instant.kt

@@ -181,20 +181,24 @@ public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Inst
     with(period) {
         val initialOffset = offsetIn(timeZone)
         val initialLdt = toLocalDateTimeFailing(initialOffset)
+        val instantAfterMonths: Instant
         val offsetAfterMonths: UtcOffset
         val ldtAfterMonths: LocalDateTime
         if (totalMonths != 0L) {
-            val (ldt, offset) = timeZone.atZone(initialLdt.plus(totalMonths, DateTimeUnit.MONTH), initialOffset)
-            offsetAfterMonths = offset
-            ldtAfterMonths = ldt
+            val unresolvedLdtWithMonths = initialLdt.plus(totalMonths, DateTimeUnit.MONTH)
+            instantAfterMonths = timeZone.localDateTimeToInstant(unresolvedLdtWithMonths, initialOffset)
+            offsetAfterMonths = instantAfterMonths.offsetIn(timeZone)
+            ldtAfterMonths = instantAfterMonths.toLocalDateTimeFailing(offsetAfterMonths)
         } else {
+            instantAfterMonths = this@plus
             offsetAfterMonths = initialOffset
             ldtAfterMonths = initialLdt
         }
         val instantAfterMonthsAndDays = if (days != 0) {
-            timeZone.atZone(ldtAfterMonths.plus(days, DateTimeUnit.DAY), offsetAfterMonths).toInstant()
+            val unresolvedLdtWithDays = ldtAfterMonths.plus(days, DateTimeUnit.DAY)
+            timeZone.localDateTimeToInstant(unresolvedLdtWithDays, offsetAfterMonths)
         } else {
-            ldtAfterMonths.toInstant(offsetAfterMonths)
+            instantAfterMonths
         }
         instantAfterMonthsAndDays
             .run { if (totalNanoseconds != 0L) plus(0, totalNanoseconds).check(timeZone) else this }
@@ -215,9 +219,9 @@ public actual fun Instant.minus(value: Int, unit: DateTimeUnit, timeZone: TimeZo
 public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZone): Instant = try {
     when (unit) {
         is DateTimeUnit.DateBased -> {
-            val preferredOffset = offsetIn(timeZone)
-            val initialLdt = toLocalDateTimeFailing(preferredOffset)
-            timeZone.atZone(initialLdt.plus(value, unit), preferredOffset).toInstant()
+            val initialOffset = offsetIn(timeZone)
+            val initialLdt = toLocalDateTimeFailing(initialOffset)
+            timeZone.localDateTimeToInstant(initialLdt.plus(value, unit), preferred = initialOffset)
         }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
@@ -240,15 +244,21 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit.TimeBased): Insta
     }
 
 public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateTimePeriod {
-    val thisOffset1 = offsetIn(timeZone)
-    val thisLdt1 = toLocalDateTimeFailing(thisOffset1)
+    val initialOffset = offsetIn(timeZone)
+    val initialLdt = toLocalDateTimeFailing(initialOffset)
     val otherLdt = other.toLocalDateTimeFailing(other.offsetIn(timeZone))
 
-    val months = thisLdt1.until(otherLdt, DateTimeUnit.MONTH) // `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) // `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
+    val months = initialLdt.until(otherLdt, DateTimeUnit.MONTH) // `until` on dates never fails
+    val unresolvedLdtWithMonths = initialLdt.plus(months, DateTimeUnit.MONTH)
+        // won't throw: thisLdt + months <= otherLdt, which is known to be valid
+    val instantWithMonths = timeZone.localDateTimeToInstant(unresolvedLdtWithMonths, preferred = initialOffset)
+    val offsetWithMonths = instantWithMonths.offsetIn(timeZone)
+    val ldtWithMonths = instantWithMonths.toLocalDateTimeFailing(offsetWithMonths)
+    val days = ldtWithMonths.until(otherLdt, DateTimeUnit.DAY) // `until` on dates never fails
+    val unresolvedLdtWithDays = ldtWithMonths.plus(days, DateTimeUnit.DAY)
+    val newInstant = timeZone.localDateTimeToInstant(unresolvedLdtWithDays, preferred = initialOffset)
+        // won't throw: thisLdt + days <= otherLdt
+    val nanoseconds = newInstant.until(other, DateTimeUnit.NANOSECOND) // |otherLdt - thisLdt| < 24h
 
     return buildDateTimePeriod(months, days.toInt(), nanoseconds)
 }

core/commonKotlin/src/LocalDateTimeWithOffset.kt

@@ -91,10 +91,7 @@ public actual open class TimeZone internal constructor() {
         throw DateTimeArithmeticException("Instant $instant is not representable as LocalDateTime.", e)
     }
 
-    internal open fun localDateTimeToInstant(dateTime: LocalDateTime): Instant =
-        atZone(dateTime).toInstant()
-
-    internal open fun atZone(dateTime: LocalDateTime, preferred: UtcOffset? = null): LocalDateTimeWithOffset =
+    internal open fun localDateTimeToInstant(dateTime: LocalDateTime, preferred: UtcOffset? = null): Instant =
         error("Should be overridden")
 
     actual override fun equals(other: Any?): Boolean =
@@ -118,11 +115,10 @@ public actual class FixedOffsetTimeZone internal constructor(public actual val o
 
     override fun offsetAtImpl(instant: Instant): UtcOffset = offset
 
-    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): LocalDateTimeWithOffset =
-        LocalDateTimeWithOffset(dateTime, offset)
+    override fun localDateTimeToInstant(dateTime: LocalDateTime, preferred: UtcOffset?): Instant =
+        dateTime.toInstant(offset)
 
     override fun instantToLocalDateTime(instant: Instant): LocalDateTime = instant.toLocalDateTime(offset)
-    override fun localDateTimeToInstant(dateTime: LocalDateTime): Instant = dateTime.toInstant(offset)
 }
 
 

core/commonKotlin/src/TimeZone.kt

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

core/commonKotlin/src/internal/RegionTimeZone.kt

@@ -33,17 +33,14 @@ class ThreeTenBpTimeZoneTest {
         val t1 = LocalDateTime(2020, 3, 29, 2, 14, 17, 201)
         val t2 = LocalDateTime(2020, 3, 29, 3, 14, 17, 201)
         val tz = TimeZone.of("Europe/Berlin")
-        assertEquals(tz.atZone(t1), tz.atZone(t2))
+        assertEquals(tz.localDateTimeToInstant(t1), tz.localDateTimeToInstant(t2))
     }
 
     @Test
     fun overlappingLocalTime() {
         val t = LocalDateTime(2007, 10, 28, 2, 30, 0, 0)
         val zone = TimeZone.of("Europe/Paris")
-        assertEquals(LocalDateTimeWithOffset(
-            LocalDateTime(2007, 10, 28, 2, 30, 0, 0),
-            UtcOffset(seconds = 2 * 3600)
-        ), zone.atZone(t))
+        assertEquals(t.toInstant(UtcOffset(hours = 2)), zone.localDateTimeToInstant(t))
     }
 
 }