Refactor native TimeZone to avoid member-extension internal functions

Override some methods in FixedOffsetTimeZone to provide a simpler implementation

Author: ilya-g

core/darwin/src/TimeZoneNative.kt

@@ -132,30 +132,30 @@ internal actual class PlatformTimeZoneImpl(private val value: NSTimeZone, overri
         return Instant(midnight.timeIntervalSince1970.toLong(), 0)
     }
 
-    override fun LocalDateTime.atZone(preferred: UtcOffset?): ZonedDateTime {
-        val epochSeconds = toEpochSecond(UtcOffset.ZERO)
+    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime {
+        val epochSeconds = dateTime.toEpochSecond(UtcOffset.ZERO)
         var offset = preferred?.totalSeconds ?: Int.MAX_VALUE
         val transitionDuration = run {
             /* a date in an unspecified timezone, defined by the number of seconds since
                the start of the epoch in *that* unspecified timezone */
             val date = dateWithTimeIntervalSince1970Saturating(epochSeconds)
             val newDate = systemDateByLocalDate(value, date)
-                ?: throw RuntimeException("Unable to acquire the offset at ${this@atZone} for zone ${this@PlatformTimeZoneImpl}")
+                ?: throw RuntimeException("Unable to acquire the offset at $dateTime for zone ${this@PlatformTimeZoneImpl}")
             // we now know the offset of that timezone at this time.
             offset = value.secondsFromGMTForDate(newDate).toInt()
             /* `dateFromComponents` automatically corrects the date to avoid gaps. We
                need to learn which adjustments it performed. */
             (newDate.timeIntervalSince1970.toLong() +
                 offset.toLong() - date.timeIntervalSince1970.toLong()).toInt()
         }
-        val dateTime = try {
-            this@atZone.plusSeconds(transitionDuration)
+        val correctedDateTime = try {
+            dateTime.plusSeconds(transitionDuration)
         } catch (e: IllegalArgumentException) {
             throw DateTimeArithmeticException("Overflow whet correcting the date-time to not be in the transition gap", e)
         } catch (e: ArithmeticException) {
             throw RuntimeException("Anomalously long timezone transition gap reported", e)
         }
-        return ZonedDateTime(dateTime, TimeZone(this@PlatformTimeZoneImpl), UtcOffset.ofSeconds(offset))
+        return ZonedDateTime(correctedDateTime, TimeZone(this), UtcOffset.ofSeconds(offset))
     }
 
     override fun offsetAt(instant: Instant): UtcOffset {

core/native/cinterop_actuals/TimeZoneNative.kt

@@ -55,22 +55,22 @@ internal actual class PlatformTimeZoneImpl(private val tzid: TZID, override val
         Instant(midnightInstantSeconds, 0)
     }
 
-    override fun LocalDateTime.atZone(preferred: UtcOffset?): ZonedDateTime = memScoped {
-        val epochSeconds = toEpochSecond(UtcOffset.ZERO)
+    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime = memScoped {
+        val epochSeconds = dateTime.toEpochSecond(UtcOffset.ZERO)
         val offset = alloc<IntVar>()
         offset.value = preferred?.totalSeconds ?: Int.MAX_VALUE
         val transitionDuration = offset_at_datetime(tzid, epochSeconds, offset.ptr)
         if (offset.value == Int.MAX_VALUE) {
-            throw RuntimeException("Unable to acquire the offset at ${this@atZone} for zone ${this@PlatformTimeZoneImpl}")
+            throw RuntimeException("Unable to acquire the offset at $dateTime for zone ${this@PlatformTimeZoneImpl}")
         }
-        val dateTime = try {
-            this@atZone.plusSeconds(transitionDuration)
+        val correctedDateTime = try {
+            dateTime.plusSeconds(transitionDuration)
         } catch (e: IllegalArgumentException) {
             throw DateTimeArithmeticException("Overflow whet correcting the date-time to not be in the transition gap", e)
         } catch (e: ArithmeticException) {
             throw RuntimeException("Anomalously long timezone transition gap reported", e)
         }
-        ZonedDateTime(dateTime, TimeZone(this@PlatformTimeZoneImpl), UtcOffset.ofSeconds(offset.value))
+        ZonedDateTime(correctedDateTime, TimeZone(this@PlatformTimeZoneImpl), UtcOffset.ofSeconds(offset.value))
     }
 
     override fun offsetAt(instant: Instant): UtcOffset {

core/native/src/Instant.kt

@@ -234,22 +234,30 @@ public actual class Instant internal constructor(public actual val epochSeconds:
 
 }
 
-private fun Instant.toZonedLocalDateTimeFailing(zone: TimeZone): ZonedDateTime = try {
-    toZonedLocalDateTime(zone)
+private fun Instant.toZonedDateTimeFailing(zone: TimeZone): ZonedDateTime = try {
+    toZonedDateTime(zone)
 } 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), zone, currentOffset)
+}
+
 /** Check that [Instant] fits in [ZonedDateTime].
  * This is done on the results of computations for consistency with other platforms.
  */
 private fun Instant.check(zone: TimeZone): Instant = this@check.also {
-    toZonedLocalDateTimeFailing(zone)
+    toZonedDateTimeFailing(zone)
 }
 
 public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Instant = try {
     with(period) {
-        val withDate = toZonedLocalDateTimeFailing(timeZone)
+        val withDate = toZonedDateTimeFailing(timeZone)
             .run { if (totalMonths != 0) plus(totalMonths, DateTimeUnit.MONTH) else this }
             .run { if (days != 0) plus(days, DateTimeUnit.DAY) else this }
         withDate.toInstant()
@@ -272,7 +280,7 @@ 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")
-            toZonedLocalDateTimeFailing(timeZone).plus(value.toInt(), unit).toInstant()
+            toZonedDateTimeFailing(timeZone).plus(value.toInt(), unit).toInstant()
         }
         is DateTimeUnit.TimeBased ->
             check(timeZone).plus(value, unit).check(timeZone)
@@ -296,8 +304,8 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit.TimeBased): Insta
 
 @OptIn(ExperimentalTime::class)
 public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateTimePeriod {
-    var thisLdt = toZonedLocalDateTimeFailing(timeZone)
-    val otherLdt = other.toZonedLocalDateTimeFailing(timeZone)
+    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
@@ -311,7 +319,7 @@ public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateT
 public actual fun Instant.until(other: Instant, unit: DateTimeUnit, timeZone: TimeZone): Long =
     when (unit) {
         is DateTimeUnit.DateBased ->
-            toZonedLocalDateTimeFailing(timeZone).dateTime.until(other.toZonedLocalDateTimeFailing(timeZone).dateTime, unit)
+            toZonedDateTimeFailing(timeZone).dateTime.until(other.toZonedDateTimeFailing(timeZone).dateTime, unit)
                 .toLong()
         is DateTimeUnit.TimeBased -> {
             check(timeZone); other.check(timeZone)

core/native/src/TimeZone.kt

@@ -61,18 +61,22 @@ public actual open class TimeZone internal constructor(internal val value: TimeZ
     public actual val id: String
         get() = value.id
 
-    public actual fun Instant.toLocalDateTime(): LocalDateTime = try {
-        toZonedLocalDateTime(this@TimeZone).dateTime
+    public actual fun Instant.toLocalDateTime(): LocalDateTime = instantToLocalDateTime(this)
+    public actual fun LocalDateTime.toInstant(): Instant = localDateTimeToInstant(this)
+
+    internal open fun atStartOfDay(date: LocalDate): Instant = value.atStartOfDay(date)
+
+    internal open fun instantToLocalDateTime(instant: Instant): LocalDateTime = try {
+        instant.toLocalDateTimeImpl(offsetAt(instant))
     } catch (e: IllegalArgumentException) {
-        throw DateTimeArithmeticException("Instant ${this@toLocalDateTime} is not representable as LocalDateTime", e)
+        throw DateTimeArithmeticException("Instant $instant is not representable as LocalDateTime.", e)
     }
 
-    public actual fun LocalDateTime.toInstant(): Instant = atZone().toInstant()
+    internal open fun localDateTimeToInstant(dateTime: LocalDateTime): Instant =
+        atZone(dateTime).toInstant()
 
-    internal open fun atStartOfDay(date: LocalDate): Instant = value.atStartOfDay(date)
-
-    internal open fun LocalDateTime.atZone(preferred: UtcOffset? = null): ZonedDateTime =
-        with(value) { atZone(preferred) }
+    internal open fun atZone(dateTime: LocalDateTime, preferred: UtcOffset? = null): ZonedDateTime =
+        value.atZone(dateTime, preferred)
 
     override fun equals(other: Any?): Boolean =
         this === other || other is TimeZone && this.value == other.value
@@ -90,14 +94,17 @@ public actual class FixedOffsetTimeZone internal constructor(public actual val u
 
     @Deprecated("Use utcOffset.totalSeconds", ReplaceWith("utcOffset.totalSeconds"))
     public actual val totalSeconds: Int get() = utcOffset.totalSeconds
+
+    override fun instantToLocalDateTime(instant: Instant): LocalDateTime = instant.toLocalDateTime(utcOffset)
+    override fun localDateTimeToInstant(dateTime: LocalDateTime): Instant = dateTime.toInstant(utcOffset)
 }
 
 
 public actual fun TimeZone.offsetAt(instant: Instant): UtcOffset =
     value.offsetAt(instant)
 
 public actual fun Instant.toLocalDateTime(timeZone: TimeZone): LocalDateTime =
-        with(timeZone) { toLocalDateTime() }
+    timeZone.instantToLocalDateTime(this)
 
 public actual fun Instant.toLocalDateTime(utcOffset: UtcOffset): LocalDateTime = try {
     toLocalDateTimeImpl(utcOffset)
@@ -115,10 +122,10 @@ internal fun Instant.toLocalDateTimeImpl(offset: UtcOffset): LocalDateTime {
 }
 
 public actual fun LocalDateTime.toInstant(timeZone: TimeZone): Instant =
-        with(timeZone) { toInstant() }
+    timeZone.localDateTimeToInstant(this)
 
 public actual fun LocalDateTime.toInstant(utcOffset: UtcOffset): Instant =
     Instant(this.toEpochSecond(utcOffset), this.nanosecond)
 
 public actual fun LocalDate.atStartOfDayIn(timeZone: TimeZone): Instant =
-        timeZone.atStartOfDay(this)
+    timeZone.atStartOfDay(this)

core/native/src/TimeZoneImpl.kt

@@ -7,7 +7,7 @@ package kotlinx.datetime
 internal interface TimeZoneImpl {
     val id: String
     fun atStartOfDay(date: LocalDate): Instant
-    fun LocalDateTime.atZone(preferred: UtcOffset?): ZonedDateTime
+    fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime
     fun offsetAt(instant: Instant): UtcOffset
 }
 
@@ -22,10 +22,10 @@ internal expect class PlatformTimeZoneImpl: TimeZoneImpl {
 internal class ZoneOffsetImpl(val utcOffset: UtcOffset, override val id: String): TimeZoneImpl {
 
     override fun atStartOfDay(date: LocalDate): Instant =
-        LocalDateTime(date, LocalTime.MIN).atZone(null).toInstant()
+        LocalDateTime(date, LocalTime.MIN).toInstant(utcOffset)
 
-    override fun LocalDateTime.atZone(preferred: UtcOffset?): ZonedDateTime {
-        return ZonedDateTime(this@atZone, utcOffset.asTimeZone(), utcOffset)
+    override fun atZone(dateTime: LocalDateTime, preferred: UtcOffset?): ZonedDateTime {
+        return ZonedDateTime(dateTime, utcOffset.asTimeZone(), utcOffset)
     }
 
     override fun offsetAt(instant: Instant): UtcOffset = utcOffset

core/native/src/ZonedDateTime.kt

@@ -24,7 +24,7 @@ internal class ZonedDateTime(val dateTime: LocalDateTime, private val zone: Time
         } 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.
-            with(zone) { atZone(offset) }
+            zone.atZone(this, offset)
         }
 
     override fun equals(other: Any?): Boolean =
@@ -48,14 +48,6 @@ internal class ZonedDateTime(val dateTime: LocalDateTime, private val zone: Time
 internal fun ZonedDateTime.toInstant(): Instant =
     Instant(dateTime.toEpochSecond(offset), dateTime.nanosecond)
 
-// org.threeten.bp.LocalDateTime#ofEpochSecond + org.threeten.bp.ZonedDateTime#create
-/**
- * @throws IllegalArgumentException if the [Instant] exceeds the boundaries of [LocalDateTime]
- */
-internal fun Instant.toZonedLocalDateTime(zone: TimeZone): ZonedDateTime {
-    val currentOffset = zone.value.offsetAt(this)
-    return ZonedDateTime(toLocalDateTimeImpl(currentOffset), zone, currentOffset)
-}
 
 // org.threeten.bp.ZonedDateTime#until
 // This version is simplified and to be used ONLY in case you know the timezones are equal!

core/native/test/ThreeTenBpTimeZoneTest.kt

@@ -45,15 +45,15 @@ 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(with(tz) { t1.atZone() }, with(tz) { t2.atZone() })
+        assertEquals(tz.atZone(t1), tz.atZone(t2))
     }
 
     @Test
     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.ofSeconds(2 * 3600)), with(zone) { t.atZone() })
+            zone, UtcOffset.ofSeconds(2 * 3600)), zone.atZone(t))
     }
 
 }