Native: use DateTimeUnit instead of CalendarUnit (#21)

Author: dkhalanskyjb

core/commonMain/src/DateTimeUnit.kt

@@ -140,3 +140,16 @@ internal enum class CalendarUnit {
     MICROSECOND,
     NANOSECOND
 }
+
+internal val CalendarUnit.dateTimeUnit: DateTimeUnit
+    get() = when (this) {
+        CalendarUnit.YEAR -> DateTimeUnit.YEAR
+        CalendarUnit.MONTH -> DateTimeUnit.MONTH
+        CalendarUnit.DAY -> DateTimeUnit.DAY
+        CalendarUnit.HOUR -> DateTimeUnit.HOUR
+        CalendarUnit.MINUTE -> DateTimeUnit.MINUTE
+        CalendarUnit.SECOND -> DateTimeUnit.SECOND
+        CalendarUnit.MILLISECOND -> DateTimeUnit.MILLISECOND
+        CalendarUnit.MICROSECOND -> DateTimeUnit.MICROSECOND
+        CalendarUnit.NANOSECOND -> DateTimeUnit.NANOSECOND
+    }

core/nativeMain/src/Instant.kt

@@ -56,7 +56,7 @@ private val instantParser: Parser<Instant>
             }
 
             // never fails: 9_999 years are always supported
-            val localDate = dateVal.withYear(dateVal.year % 10000).plus(days, CalendarUnit.DAY)
+            val localDate = dateVal.withYear(dateVal.year % 10000).plus(days, DateTimeUnit.DAY)
             val localTime = LocalTime.of(hours, min, seconds, 0)
             val secDelta: Long = try {
                 safeMultiply((dateVal.year / 10000).toLong(), SECONDS_PER_10000_YEARS)
@@ -285,10 +285,9 @@ private fun Instant.check(zone: TimeZone): Instant = [email protected] {
 actual fun Instant.plus(period: DateTimePeriod, zone: TimeZone): Instant = try {
     with(period) {
         val withDate = toZonedLocalDateTimeFailing(zone)
-            .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 }
-        // See [Instant.plus(Instant, long, CalendarUnit, TimeZone)] for an explanation of time inside day being special
+            .run { if (years != 0 && months == 0) plus(years.toLong(), DateTimeUnit.YEAR) else this }
+            .run { if (months != 0) plus(years * 12L + months.toLong(), DateTimeUnit.MONTH) else this }
+            .run { if (days != 0) plus(days.toLong(), DateTimeUnit.DAY) else this }
         val secondsToAdd = safeAdd(seconds,
             safeAdd(minutes.toLong() * SECONDS_PER_MINUTE, hours.toLong() * SECONDS_PER_HOUR))
         withDate.toInstant().plus(secondsToAdd, period.nanoseconds)
@@ -299,33 +298,15 @@ actual fun Instant.plus(period: DateTimePeriod, zone: TimeZone): Instant = try {
     throw DateTimeArithmeticException("Boundaries of Instant exceeded when adding CalendarPeriod", e)
 }
 
-internal actual fun Instant.plus(value: Long, unit: CalendarUnit, zone: TimeZone): Instant = try {
+internal actual fun Instant.plus(value: Long, unit: CalendarUnit, zone: TimeZone): Instant =
+    plusDateTimeUnit(value, unit.dateTimeUnit, zone)
+
+internal fun Instant.plusDateTimeUnit(value: Long, unit: DateTimeUnit, zone: TimeZone): Instant = try {
     when (unit) {
-        CalendarUnit.YEAR -> toZonedLocalDateTimeFailing(zone).plusYears(value).toInstant()
-        CalendarUnit.MONTH -> toZonedLocalDateTimeFailing(zone).plusMonths(value).toInstant()
-        CalendarUnit.DAY -> toZonedLocalDateTimeFailing(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,
-           finds an applicable offset and builds the local representation of the zoned datetime.
-           If we then feed the result to org.threeten.bp.chrono.ChronoZonedDateTime#toInstant, it simply
-           builds the instant with org.threeten.bp.chrono.ChronoZonedDateTime#toEpochSecond, which, once
-           more, finds the absolute instant. Thus, we can summarize the composition of `atZone`, `plusHours`
-           and `toInstant` like this:
-           1. An absolute instant is converted to a zoned datetime by adding an offset;
-           2. Time is added to a datetime, ignoring the offset;
-           3. Using the know offset, it is converted to an absolute instant;
-           4. The instant is adapted to a zoned datetime representation;
-           5. The zoned datetime is converted to an absolute instant.
-           4 and 5 are invertible by their form: their composition adds and subtracts the offset to and from
-           the unix epoch. 1-3 can then be simplified to just adding the time to the instant directly.
-         */
-        CalendarUnit.HOUR -> plus(safeMultiply(value, SECONDS_PER_HOUR.toLong()), 0).check(zone)
-        CalendarUnit.MINUTE -> plus(safeMultiply(value, SECONDS_PER_MINUTE.toLong()), 0).check(zone)
-        CalendarUnit.SECOND -> plus(value, 0).check(zone)
-        CalendarUnit.MILLISECOND -> plus(value / MILLIS_PER_ONE, (value % MILLIS_PER_ONE) * NANOS_PER_MILLI).check(zone)
-        CalendarUnit.MICROSECOND -> plus(value / MICROS_PER_ONE, (value % MICROS_PER_ONE) * NANOS_PER_MICRO).check(zone)
-        CalendarUnit.NANOSECOND -> plus(0, value).check(zone)
+        is DateTimeUnit.DateBased -> toZonedLocalDateTimeFailing(zone).plus(value, unit).toInstant()
+        is DateTimeUnit.TimeBased -> multiplyAndDivide(value, unit.nanoseconds, NANOS_PER_ONE.toLong()).let {
+            (seconds, nanoseconds) -> check(zone).plus(seconds, nanoseconds).check(zone)
+        }
     }
 } catch (e: ArithmeticException) {
     throw DateTimeArithmeticException("Arithmetic overflow when adding to an Instant", e)
@@ -338,21 +319,30 @@ actual fun Instant.periodUntil(other: Instant, zone: TimeZone): DateTimePeriod {
     var thisLdt = toZonedLocalDateTimeFailing(zone)
     val otherLdt = other.toZonedLocalDateTimeFailing(zone)
 
-    val months = thisLdt.until(otherLdt, CalendarUnit.MONTH) // `until` on dates never fails
-    thisLdt = thisLdt.plusMonths(months) // won't throw: thisLdt + months <= otherLdt, which is known to be valid
-    val days = thisLdt.until(otherLdt, CalendarUnit.DAY) // `until` on dates never fails
-    thisLdt = thisLdt.plusDays(days) // won't throw: thisLdt + days <= otherLdt
-    val time = thisLdt.until(otherLdt, CalendarUnit.NANOSECOND).nanoseconds // |otherLdt - thisLdt| < 24h
+    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 time = thisLdt.until(otherLdt, DateTimeUnit.NANOSECOND).nanoseconds // |otherLdt - thisLdt| < 24h
 
     time.toComponents { hours, minutes, seconds, nanoseconds ->
         return DateTimePeriod((months / 12).toInt(), (months % 12).toInt(), days.toInt(), hours, minutes, seconds.toLong(), nanoseconds.toLong())
     }
 }
 
 public actual fun Instant.until(other: Instant, unit: DateTimeUnit, zone: TimeZone): Long =
-    try {
-        // TODO: inline 'until' here and simplify operation for time-based units
-        toZonedLocalDateTimeFailing(zone).until(other.toZonedLocalDateTimeFailing(zone), unit.calendarUnit) / unit.calendarScale
-    } catch (e: ArithmeticException) {
-        if (this < other) Long.MAX_VALUE else Long.MIN_VALUE
+    when (unit) {
+        is DateTimeUnit.DateBased ->
+            toZonedLocalDateTimeFailing(zone).dateTime.until(other.toZonedLocalDateTimeFailing(zone).dateTime, unit)
+        is DateTimeUnit.TimeBased -> {
+            check(zone); other.check(zone)
+            try {
+                multiplyAddAndDivide(other.epochSeconds - epochSeconds,
+                    NANOS_PER_ONE.toLong(),
+                    (other.nanosecondsOfSecond - nanosecondsOfSecond).toLong(),
+                    unit.nanoseconds)
+            } catch (e: ArithmeticException) {
+                if (this < other) Long.MAX_VALUE else Long.MIN_VALUE
+            }
+        }
     }

core/nativeMain/src/LocalDate.kt

@@ -186,9 +186,12 @@ public actual class LocalDate actual constructor(actual val year: Int, actual va
         }
         val monthCount: Long = year * 12L + (monthNumber - 1)
         val calcMonths = safeAdd(monthCount, monthsToAdd)
-        val newYear: Int = floorDiv(calcMonths, 12).toInt()
+        val newYear = floorDiv(calcMonths, 12)
+        if (newYear < Int.MIN_VALUE || newYear > Int.MAX_VALUE) {
+            throw ArithmeticException("Addition overflows an Int")
+        }
         val newMonth = floorMod(calcMonths, 12).toInt() + 1
-        return resolvePreviousValid(newYear, newMonth, dayOfMonth)
+        return resolvePreviousValid(newYear.toInt(), newMonth, dayOfMonth)
     }
 
     // org.threeten.bp.LocalDate#plusWeeks
@@ -250,25 +253,20 @@ public actual class LocalDate actual constructor(actual val year: Int, actual va
 }
 
 internal actual fun LocalDate.plus(value: Long, unit: CalendarUnit): LocalDate =
-    when (unit) {
-        CalendarUnit.YEAR, CalendarUnit.MONTH, CalendarUnit.DAY -> try {
-            when (unit) {
-                CalendarUnit.YEAR -> plusYears(value)
-                CalendarUnit.MONTH -> plusMonths(value)
-                CalendarUnit.DAY -> plusDays(value)
-                else -> throw RuntimeException("impossible")
-            }
-        } catch (e: ArithmeticException) {
-            throw DateTimeArithmeticException("Arithmetic overflow when adding a value to a date", e)
-        } catch (e: IllegalArgumentException) {
-            throw DateTimeArithmeticException("Boundaries of LocalDate exceeded when adding a value", e)
+    if (unit.dateTimeUnit is DateTimeUnit.DateBased)
+        plusDateTimeUnit(value, unit.dateTimeUnit as DateTimeUnit.DateBased)
+    else throw IllegalArgumentException("Only date based units can be added to LocalDate")
+
+internal fun LocalDate.plusDateTimeUnit(value: Long, unit: DateTimeUnit.DateBased): LocalDate =
+    try {
+        when (unit) {
+            is DateTimeUnit.DateBased.DayBased -> plusDays(safeMultiply(value, unit.days.toLong()))
+            is DateTimeUnit.DateBased.MonthBased -> plusMonths(safeMultiply(value, unit.months.toLong()))
         }
-        CalendarUnit.HOUR,
-        CalendarUnit.MINUTE,
-        CalendarUnit.SECOND,
-        CalendarUnit.MILLISECOND,
-        CalendarUnit.MICROSECOND,
-        CalendarUnit.NANOSECOND -> throw IllegalArgumentException("Only date based units can be added to LocalDate")
+    } catch (e: ArithmeticException) {
+        throw DateTimeArithmeticException("Arithmetic overflow when adding a value to a date", e)
+    } catch (e: IllegalArgumentException) {
+        throw DateTimeArithmeticException("Boundaries of LocalDate exceeded when adding a value", e)
     }
 
 internal actual fun LocalDate.plus(value: Int, unit: CalendarUnit): LocalDate =
@@ -279,8 +277,8 @@ actual operator fun LocalDate.plus(period: DatePeriod): LocalDate =
         try {
             this@plus
                 .run { if (years != 0 && months == 0) plusYears(years.toLong()) else this }
-                .run { if (months != 0) this.plusMonths(years * 12L + months.toLong()) else this }
-                .run { if (days != 0) this.plusDays(days.toLong()) else this }
+                .run { if (months != 0) plusMonths(years * 12L + months.toLong()) else this }
+                .run { if (days != 0) plusDays(days.toLong()) else this }
         } catch (e: ArithmeticException) {
             throw DateTimeArithmeticException("Arithmetic overflow when adding a period to a date", e)
         } catch (e: IllegalArgumentException) {
@@ -308,22 +306,8 @@ internal fun LocalDate.longMonthsUntil(other: LocalDate): Long {
     return (packed2 - packed1) / 32
 }
 
-// org.threeten.bp.LocalDate#until(org.threeten.bp.temporal.Temporal, org.threeten.bp.temporal.TemporalUnit)
-internal fun LocalDate.longUntil(end: LocalDate, unit: CalendarUnit): Long =
-    when (unit) {
-        CalendarUnit.DAY -> longDaysUntil(end)
-        CalendarUnit.MONTH -> longMonthsUntil(end)
-        CalendarUnit.YEAR -> longMonthsUntil(end) / 12
-        CalendarUnit.HOUR,
-        CalendarUnit.MINUTE,
-        CalendarUnit.SECOND,
-        CalendarUnit.MILLISECOND,
-        CalendarUnit.MICROSECOND,
-        CalendarUnit.NANOSECOND -> throw IllegalArgumentException("Unsupported unit: $unit")
-    }
-
 actual fun LocalDate.periodUntil(other: LocalDate): DatePeriod {
-    val months = longUntil(other, CalendarUnit.MONTH)
-    val days = plusMonths(months).longUntil(other, CalendarUnit.DAY)
+    val months = longMonthsUntil(other)
+    val days = plusMonths(months).longDaysUntil(other)
     return DatePeriod((months / 12).toInt(), (months % 12).toInt(), days.toInt())
 }

core/nativeMain/src/LocalDateTime.kt

@@ -71,18 +71,8 @@ public actual class LocalDateTime internal constructor(
      * @throws IllegalArgumentException if the result exceeds the boundaries
      * @throws ArithmeticException if arithmetic overflow occurs
      */
-    internal fun plusYears(years: Long): LocalDateTime = LocalDateTime(date.plusYears(years), time)
-    /**
-     * @throws IllegalArgumentException if the result exceeds the boundaries
-     * @throws ArithmeticException if arithmetic overflow occurs
-     */
-    internal fun plusMonths(months: Long): LocalDateTime = LocalDateTime(date.plusMonths(months), time)
-    /**
-     * @throws IllegalArgumentException if the result exceeds the boundaries
-     * @throws ArithmeticException if arithmetic overflow occurs
-     */
-    internal fun plusDays(days: Long): LocalDateTime = LocalDateTime(date.plusDays(days), time)
-
+    internal fun plus(value: Long, unit: DateTimeUnit.DateBased): LocalDateTime =
+        LocalDateTime(date.plusDateTimeUnit(value, unit), time)
 }
 
 actual fun Instant.toLocalDateTime(timeZone: TimeZone): LocalDateTime =
@@ -95,44 +85,26 @@ actual fun Instant.offsetAt(timeZone: TimeZone): ZoneOffset =
     with(timeZone) { offset }
 
 // org.threeten.bp.LocalDateTime#until
-/** @throws ArithmeticException on arithmetic overflow. Only possible for time-based units. */
-internal fun LocalDateTime.until(other: LocalDateTime, unit: CalendarUnit): Long =
-    when (unit) {
-        CalendarUnit.YEAR, CalendarUnit.MONTH, CalendarUnit.DAY -> {
-            var endDate: LocalDate = other.date
-            if (endDate > date && other.time < time) {
-                endDate = endDate.plusDays(-1) // won't throw: endDate - date >= 1
-            } else if (endDate < date && other.time > time) {
-                endDate = endDate.plusDays(1) // won't throw: date - endDate >= 1
-            }
-            date.longUntil(endDate, unit)
-        }
-        CalendarUnit.HOUR, CalendarUnit.MINUTE, CalendarUnit.SECOND, CalendarUnit.MILLISECOND, CalendarUnit.MICROSECOND, CalendarUnit.NANOSECOND -> {
-            var daysUntil = date.longDaysUntil(other.date)
-            var timeUntil: Long = other.time.toNanoOfDay() - time.toNanoOfDay()
-            if (daysUntil > 0 && timeUntil < 0) {
-                daysUntil--
-                timeUntil += NANOS_PER_DAY
-            } else if (daysUntil < 0 && timeUntil > 0) {
-                daysUntil++
-                timeUntil -= NANOS_PER_DAY
-            }
-            val nanos = timeUntil
-            when (unit) {
-                CalendarUnit.HOUR -> safeAdd(nanos / NANOS_PER_HOUR, safeMultiply(daysUntil, HOURS_PER_DAY.toLong()))
-                CalendarUnit.MINUTE -> safeAdd(nanos / NANOS_PER_MINUTE,
-                    safeMultiply(daysUntil, MINUTES_PER_DAY.toLong()))
-                CalendarUnit.SECOND -> safeAdd(nanos / NANOS_PER_ONE,
-                    safeMultiply(daysUntil, SECONDS_PER_DAY.toLong()))
-                CalendarUnit.MILLISECOND -> safeAdd(nanos / NANOS_PER_MILLI,
-                    safeMultiply(daysUntil, SECONDS_PER_DAY.toLong() * MILLIS_PER_ONE))
-                CalendarUnit.MICROSECOND -> safeAdd(nanos / NANOS_PER_MICRO,
-                    safeMultiply(daysUntil, SECONDS_PER_DAY.toLong() * MICROS_PER_ONE))
-                CalendarUnit.NANOSECOND -> safeAdd(nanos, safeMultiply(daysUntil, NANOS_PER_DAY))
-                else -> throw RuntimeException("impossible")
-            }
-        }
+internal fun LocalDateTime.until(other: LocalDateTime, unit: DateTimeUnit.DateBased): Long {
+    var endDate: LocalDate = other.date
+    if (endDate > date && other.time < time) {
+        endDate = endDate.plusDays(-1) // won't throw: endDate - date >= 1
+    } else if (endDate < date && other.time > time) {
+        endDate = endDate.plusDays(1) // won't throw: date - endDate >= 1
+    }
+    return when (unit) {
+        is DateTimeUnit.DateBased.MonthBased -> date.longMonthsUntil(endDate) / unit.months
+        is DateTimeUnit.DateBased.DayBased -> date.longDaysUntil(endDate) / unit.days
     }
+}
+
+// org.threeten.bp.LocalDateTime#until
+/** @throws ArithmeticException on arithmetic overflow. */
+internal fun LocalDateTime.until(other: LocalDateTime, unit: DateTimeUnit.TimeBased): Long {
+    val daysUntil = date.longDaysUntil(other.date)
+    val timeUntil: Long = other.time.toNanoOfDay() - time.toNanoOfDay()
+    return multiplyAddAndDivide(daysUntil, NANOS_PER_DAY, timeUntil, unit.nanoseconds)
+}
 
 // org.threeten.bp.LocalDateTime#plusSeconds
 /**