Native (Kotlin): Fix a bug with Instant.plus (#3)

* Native (Kotlin): Fix a bug with `Instant.plus`

There was a problem with `Instant.plus` failing to adjust an
intermediate date due to offset changing. This led to behaviour
different from other platforms and `plus` and `periodUntil` not
being inverse operations.

Author: dkhalanskyjb

core/commonTest/src/InstantTest.kt

@@ -127,6 +127,15 @@ class InstantTest {
         assertEquals(offset1, offset3)
     }
 
+    @Test
+    fun changingTimeZoneRules() {
+        val start = Instant.parse("1991-01-25T23:15:15.855Z")
+        val end = Instant.parse("2006-04-24T22:07:32.561Z")
+        val diff = start.periodUntil(end, TimeZone.of("Europe/Moscow"))
+        val end2 = start.plus(diff, TimeZone.of("Europe/Moscow"))
+        assertEquals(end, end2)
+    }
+
     @Test
     fun diffInvariant() {
         repeat(1000) {

core/nativeMain/src/Instant.kt

@@ -164,17 +164,15 @@ public actual class Instant internal constructor(internal val epochSeconds: Long
     }
 
     actual companion object {
-        actual fun now(): Instant {
-            return memScoped {
-                val timespecBuf = alloc<timespec>()
-                val error = clock_gettime(CLOCK_REALTIME, timespecBuf.ptr)
-                assertEquals(0, error)
-                // according to https://en.cppreference.com/w/c/chrono/timespec,
-                // tv_nsec in [0; 10^9), so no need to call [ofEpochSecond].
-                val seconds = timespecBuf.tv_sec.toLong() // conversion is needed on some platforms
-                val nanosec = timespecBuf.tv_nsec.toInt()
-                Instant(seconds, nanosec)
-            }
+        actual fun now(): Instant = memScoped {
+            val timespecBuf = alloc<timespec>()
+            val error = clock_gettime(CLOCK_REALTIME, timespecBuf.ptr)
+            assertEquals(0, error)
+            // according to https://en.cppreference.com/w/c/chrono/timespec,
+            // tv_nsec in [0; 10^9), so no need to call [ofEpochSecond].
+            val seconds = timespecBuf.tv_sec.toLong() // conversion is needed on some platforms
+            val nanosec = timespecBuf.tv_nsec.toInt()
+            Instant(seconds, nanosec)
         }
 
         // org.threeten.bp.Instant#ofEpochMilli
@@ -202,24 +200,24 @@ actual fun Instant.plus(period: CalendarPeriod, zone: TimeZone): Instant {
             minutes.toLong() * SECONDS_PER_MINUTE,
             hours.toLong() * SECONDS_PER_HOUR))
     }
-    val localDateTime = toLocalDateTime(zone)
+    val localDateTime = toZonedLocalDateTime(zone)
     return with(period) {
         localDateTime
             .run { if (years != 0 && months == 0) plusYears(years.toLong()) else this }
             .run { if (months != 0) plusMonths(years * 12L + months.toLong()) else this }
             .run { if (days != 0) plusDays(days.toLong()) else this }
-    }.toInstant(zone).plus(seconds, period.nanoseconds)
+    }.toInstant().plus(seconds, period.nanoseconds)
 }
 
 actual fun Instant.plus(value: Int, unit: CalendarUnit, zone: TimeZone): Instant =
     plus(value.toLong(), unit, zone)
 
 actual fun Instant.plus(value: Long, unit: CalendarUnit, zone: TimeZone): Instant =
     when (unit) {
-        CalendarUnit.YEAR -> toLocalDateTime(zone).plusYears(value).toInstant(zone)
-        CalendarUnit.MONTH -> toLocalDateTime(zone).plusMonths(value).toInstant(zone)
-        CalendarUnit.WEEK -> toLocalDateTime(zone).plusDays(value * 7).toInstant(zone)
-        CalendarUnit.DAY -> toLocalDateTime(zone).plusDays(value).toInstant(zone)
+        CalendarUnit.YEAR -> toZonedLocalDateTime(zone).plusYears(value).toInstant()
+        CalendarUnit.MONTH -> toZonedLocalDateTime(zone).plusMonths(value).toInstant()
+        CalendarUnit.WEEK -> toZonedLocalDateTime(zone).plusDays(value * 7).toInstant()
+        CalendarUnit.DAY -> toZonedLocalDateTime(zone).plusDays(value).toInstant()
         /* From org.threeten.bp.ZonedDateTime#plusHours: the time is added to the raw LocalDateTime,
            then org.threeten.bp.ZonedDateTime#create is called on the absolute instant
            (gotten from org.threeten.bp.chrono.ChronoLocalDateTime#toEpochSecond). This, in turn,
@@ -244,8 +242,8 @@ actual fun Instant.plus(value: Long, unit: CalendarUnit, zone: TimeZone): Instan
 
 @OptIn(ExperimentalTime::class)
 actual fun Instant.periodUntil(other: Instant, zone: TimeZone): CalendarPeriod {
-    var thisLdt = with(zone) { toZonedLocalDateTime() }
-    val otherLdt = with(zone) { other.toZonedLocalDateTime() }
+    var thisLdt = toZonedLocalDateTime(zone)
+    val otherLdt = other.toZonedLocalDateTime(zone)
 
     val months = thisLdt.until(otherLdt, CalendarUnit.MONTH); thisLdt = thisLdt.plusMonths(months)
     val days = thisLdt.until(otherLdt, CalendarUnit.DAY); thisLdt = thisLdt.plusDays(days)
@@ -257,7 +255,7 @@ actual fun Instant.periodUntil(other: Instant, zone: TimeZone): CalendarPeriod {
 }
 
 actual fun Instant.until(other: Instant, unit: CalendarUnit, zone: TimeZone): Long =
-    with(zone) { toZonedLocalDateTime().until(other.toZonedLocalDateTime(), unit) }
+    toZonedLocalDateTime(zone).until(other.toZonedLocalDateTime(zone), unit)
 
 actual fun Instant.daysUntil(other: Instant, zone: TimeZone): Int = until(other, CalendarUnit.DAY, zone).toInt()
 actual fun Instant.monthsUntil(other: Instant, zone: TimeZone): Int = until(other, CalendarUnit.MONTH, zone).toInt()

core/nativeMain/src/LocalDate.kt

@@ -30,6 +30,7 @@ public actual class LocalDate private constructor(actual val year: Int, actual v
 
         // org.threeten.bp.LocalDate#toEpochDay
         internal fun ofEpochDay(epochDay: Long): LocalDate {
+            require(epochDay in -365243219162L..365241780471L)
             var zeroDay: Long = epochDay + DAYS_0000_TO_1970
             // find the march-based year
             zeroDay -= 60 // adjust to 0000-03-01 so leap day is at end of four year cycle

core/nativeMain/src/TimeZone.kt

@@ -78,17 +78,7 @@ public actual open class TimeZone internal constructor(actual val id: String) {
             }
     }
 
-    // org.threeten.bp.LocalDateTime#ofEpochSecond + org.threeten.bp.ZonedDateTime#create
-    internal fun Instant.toZonedLocalDateTime(): ZonedDateTime {
-        val localSecond: Long = epochSeconds + offset.totalSeconds // overflow caught later
-        val localEpochDay: Long = floorDiv(localSecond, SECONDS_PER_DAY.toLong())
-        val secsOfDay: Long = floorMod(localSecond, SECONDS_PER_DAY.toLong())
-        val date: LocalDate = LocalDate.ofEpochDay(localEpochDay)
-        val time: LocalTime = LocalTime.ofSecondOfDay(secsOfDay, nanos)
-        return ZonedDateTime(LocalDateTime(date, time), this@TimeZone, offset)
-    }
-
-    actual fun Instant.toLocalDateTime(): LocalDateTime = toZonedLocalDateTime().dateTime
+    actual fun Instant.toLocalDateTime(): LocalDateTime = toZonedLocalDateTime(this@TimeZone).dateTime
 
     actual open val Instant.offset: ZoneOffset
         get() {
@@ -99,10 +89,8 @@ public actual open class TimeZone internal constructor(actual val id: String) {
             return ZoneOffset(offset)
         }
 
-    actual fun LocalDateTime.toInstant(): Instant {
-        val zoned = atZone()
-        return Instant(zoned.dateTime.toEpochSecond(zoned.offset), nanosecond)
-    }
+    actual fun LocalDateTime.toInstant(): Instant =
+        atZone().toInstant()
 
     internal open fun LocalDateTime.atZone(preferred: ZoneOffset? = null): ZonedDateTime = memScoped {
         val epochSeconds = toEpochSecond(ZoneOffset(0))

core/nativeMain/src/ZonedDateTime.kt

@@ -33,6 +33,20 @@ 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
+internal fun Instant.toZonedLocalDateTime(zone: TimeZone): ZonedDateTime {
+    val currentOffset = with (zone) { offset }
+    val localSecond: Long = epochSeconds + currentOffset.totalSeconds // overflow caught later
+    val localEpochDay: Long = floorDiv(localSecond, SECONDS_PER_DAY.toLong())
+    val secsOfDay: Long = floorMod(localSecond, SECONDS_PER_DAY.toLong())
+    val date: LocalDate = LocalDate.ofEpochDay(localEpochDay)
+    val time: LocalTime = LocalTime.ofSecondOfDay(secsOfDay, nanos)
+    return ZonedDateTime(LocalDateTime(date, time), zone, currentOffset)
+}
+
 // org.threeten.bp.ZonedDateTime#until
 // This version is simplified and to be used ONLY in case you know the timezones are equal!
 internal fun ZonedDateTime.until(other: ZonedDateTime, unit: CalendarUnit): Long =