Remove ZonedDateTime from the Native implementation

Author: dkhalanskyjb

core/native/src/Instant.kt

@@ -271,7 +271,7 @@ public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Inst
         val newLdt = toLocalDateTimeFailing(initialOffset)
             .run { if (totalMonths != 0) { plus(totalMonths, DateTimeUnit.MONTH) } else { this } }
             .run { if (days != 0) { plus(days, DateTimeUnit.DAY) } else { this } }
-        timeZone.atZone(newLdt, preferred = initialOffset).toInstant()
+        timeZone.localDateTimeToInstant(newLdt, preferred = initialOffset)
             .run { if (totalNanoseconds != 0L) plus(0, totalNanoseconds).check(timeZone) else this }
     }.check(timeZone)
 } catch (e: ArithmeticException) {
@@ -294,7 +294,7 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
                 throw ArithmeticException("Can't add a Long date-based value, as it would cause an overflow")
             val initialOffset = offsetIn(timeZone)
             val initialLdt = toLocalDateTimeFailing(initialOffset)
-            timeZone.atZone(initialLdt.plus(value.toInt(), unit), preferred = initialOffset).toInstant()
+            timeZone.localDateTimeToInstant(initialLdt.plus(value.toInt(), unit), preferred = initialOffset)
         }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
@@ -324,7 +324,7 @@ public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateT
     val months = initialLdt.until(otherLdt, DateTimeUnit.MONTH).toLong().toInt() // `until` on dates never fails
     val ldtWithMonths = initialLdt.plus(months, DateTimeUnit.MONTH) // won't throw: thisLdt + months <= otherLdt, which is known to be valid
     val days = ldtWithMonths.until(otherLdt, DateTimeUnit.DAY).toLong().toInt() // `until` on dates never fails
-    val newInstant = timeZone.atZone(ldtWithMonths.plus(days, DateTimeUnit.DAY), preferred = initialOffset).toInstant() // won't throw: thisLdt + days <= otherLdt
+    val newInstant = timeZone.localDateTimeToInstant(ldtWithMonths.plus(days, DateTimeUnit.DAY), preferred = initialOffset) // won't throw: thisLdt + days <= otherLdt
     val nanoseconds = newInstant.until(other, DateTimeUnit.NANOSECOND) // |otherLdt - thisLdt| < 24h
 
     return buildDateTimePeriod(months, days, nanoseconds)

core/native/src/LocalDateTimeWithOffset.kt

@@ -85,10 +85,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")
 
     override fun equals(other: Any?): Boolean =
@@ -112,11 +109,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/native/src/TimeZone.kt

@@ -27,12 +27,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",
@@ -41,8 +41,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/native/src/internal/RegionTimeZone.kt

@@ -34,17 +34,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))
     }
 
 }