Fix deprecations and other warnings after updating to Kotlin 1.5

Author: ilya-g

core/common/src/DateTimePeriod.kt

@@ -162,7 +162,7 @@ public sealed class DateTimePeriod {
                         parseException("Value $this does not fit into an Int, which is required for component '$component'", iStart)
                     return toInt()
                 }
-                when (text[i].toUpperCase()) {
+                when (text[i].uppercaseChar()) {
                     'Y' -> {
                         if (state >= AFTER_YEAR)
                             parseException(wrongOrder, i)
@@ -308,7 +308,7 @@ public fun DateTimePeriod(
     totalNanoseconds(hours, minutes, seconds, nanoseconds))
 
 @OptIn(ExperimentalTime::class)
-public fun Duration.toDateTimePeriod(): DateTimePeriod = buildDateTimePeriod(totalNanoseconds = toLongNanoseconds())
+public fun Duration.toDateTimePeriod(): DateTimePeriod = buildDateTimePeriod(totalNanoseconds = inWholeNanoseconds)
 
 public operator fun DateTimePeriod.plus(other: DateTimePeriod): DateTimePeriod = buildDateTimePeriod(
     safeAdd(totalMonths, other.totalMonths),

core/common/src/DateTimeUnit.kt

@@ -54,7 +54,7 @@ public sealed class DateTimeUnit {
 
         @ExperimentalTime
         public val duration: Duration
-            get() = nanoseconds.nanoseconds
+            get() = Duration.nanoseconds(nanoseconds)
 
         override fun equals(other: Any?): Boolean =
                 this === other || (other is TimeBased && this.nanoseconds == other.nanoseconds)

core/common/test/DateTimePeriodTest.kt

@@ -160,10 +160,10 @@ class DateTimePeriodTest {
         assertTrue(periodZero is DatePeriod)
 
         for ((period, duration) in listOf(
-                DateTimePeriod(hours = 1) to 1.hours,
-                DateTimePeriod(hours = 2) to 120.minutes,
-                DateTimePeriod(minutes = 2, seconds = 30) to 150.seconds,
-                DateTimePeriod(seconds = 2) to 2e9.nanoseconds
+                DateTimePeriod(hours = 1) to Duration.hours(1),
+                DateTimePeriod(hours = 2) to Duration.minutes(120),
+                DateTimePeriod(minutes = 2, seconds = 30) to Duration.seconds(150),
+                DateTimePeriod(seconds = 2) to Duration.nanoseconds(2e9)
         )) {
             assertEquals(period, duration.toDateTimePeriod())
         }

core/common/test/InstantTest.kt

@@ -35,7 +35,7 @@ class InstantTest {
     fun instantArithmetic() {
         val instant = Clock.System.now().toEpochMilliseconds().let { Instant.fromEpochMilliseconds(it) } // round to millis
         val diffMillis = Random.nextLong(1000, 1_000_000_000)
-        val diff = diffMillis.milliseconds
+        val diff = Duration.milliseconds(diffMillis)
 
         val nextInstant = (instant.toEpochMilliseconds() + diffMillis).let { Instant.fromEpochMilliseconds(it) }
 
@@ -180,7 +180,7 @@ class InstantTest {
         checkComponents(instant5.toLocalDateTime(zone), 2019, 10, 28, 3, 59)
         assertEquals(period, instant1.periodUntil(instant5, zone))
         assertEquals(period, instant5.minus(instant1, zone))
-        assertEquals(26.hours, instant5.minus(instant1))
+        assertEquals(Duration.hours(26), instant5.minus(instant1))
         assertEquals(instant1.plus(DateTimeUnit.HOUR), instant5.minus(period, zone))
 
         val instant6 = instant1.plus(23, DateTimeUnit.HOUR, zone)
@@ -237,15 +237,15 @@ class InstantTest {
         checkComponents(ldt1, 2019, 10, 27, 2, 59)
         assertEquals(instant1, ldt1.toInstant(offset1))
 
-        val instant2 = instant1 + 1.hours
+        val instant2 = instant1 + Duration.hours(1)
         val ldt2 = instant2.toLocalDateTime(zone)
         val offset2 = instant2.offsetIn(zone)
         assertEquals(ldt1, ldt2)
         assertEquals(instant2, ldt2.toInstant(offset2))
         assertNotEquals(offset1, offset2)
-        assertEquals(offset1.totalSeconds.seconds, offset2.totalSeconds.seconds + 1.hours)
+        assertEquals(Duration.seconds(offset1.totalSeconds), Duration.seconds(offset2.totalSeconds) + Duration.hours(1))
 
-        val instant3 = instant2 - 2.hours
+        val instant3 = instant2 - Duration.hours(2)
         val offset3 = instant3.offsetIn(zone)
         assertEquals(offset1, offset3)
     }
@@ -414,10 +414,10 @@ class InstantTest {
         assertTrue(Instant.DISTANT_FUTURE.isDistantFuture)
         assertFalse(Instant.DISTANT_PAST.isDistantFuture)
         assertFalse(Instant.DISTANT_FUTURE.isDistantPast)
-        assertFalse((Instant.DISTANT_PAST + 1.nanoseconds).isDistantPast)
-        assertFalse((Instant.DISTANT_FUTURE - 1.nanoseconds).isDistantFuture)
-        assertTrue((Instant.DISTANT_PAST - 1.nanoseconds).isDistantPast)
-        assertTrue((Instant.DISTANT_FUTURE + 1.nanoseconds).isDistantFuture)
+        assertFalse((Instant.DISTANT_PAST + Duration.nanoseconds(1)).isDistantPast)
+        assertFalse((Instant.DISTANT_FUTURE - Duration.nanoseconds(1)).isDistantFuture)
+        assertTrue((Instant.DISTANT_PAST - Duration.nanoseconds(1)).isDistantPast)
+        assertTrue((Instant.DISTANT_FUTURE + Duration.nanoseconds(1)).isDistantFuture)
         assertTrue(Instant.MAX.isDistantFuture)
         assertFalse(Instant.MAX.isDistantPast)
         assertTrue(Instant.MIN.isDistantPast)
@@ -435,8 +435,8 @@ class InstantRangeTest {
     private val largePositiveLongs = listOf(Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE - 50)
     private val largeNegativeLongs = listOf(Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 50)
 
-    private val largePositiveInstants = listOf(Instant.MAX, Instant.MAX - 1.seconds, Instant.MAX - 50.seconds)
-    private val largeNegativeInstants = listOf(Instant.MIN, Instant.MIN + 1.seconds, Instant.MIN + 50.seconds)
+    private val largePositiveInstants = listOf(Instant.MAX, Instant.MAX - Duration.seconds(1), Instant.MAX - Duration.seconds(50))
+    private val largeNegativeInstants = listOf(Instant.MIN, Instant.MIN + Duration.seconds(1), Instant.MIN + Duration.seconds(50))
 
     private val smallInstants = listOf(
         Instant.fromEpochMilliseconds(0),
@@ -494,7 +494,7 @@ class InstantRangeTest {
 
     @Test
     fun durationArithmeticClamping() {
-        val longDurations = listOf(Duration.INFINITE, Double.MAX_VALUE.nanoseconds, Long.MAX_VALUE.seconds)
+        val longDurations = listOf(Duration.INFINITE)
 
         for (duration in longDurations) {
             for (instant in smallInstants + largeNegativeInstants + largePositiveInstants) {
@@ -504,8 +504,8 @@ class InstantRangeTest {
                 assertEquals(Instant.MIN, instant - duration)
             }
         }
-        assertEquals(Instant.MAX, (Instant.MAX - 4.seconds) + 5.seconds)
-        assertEquals(Instant.MIN, (Instant.MIN + 10.seconds) - 12.seconds)
+        assertEquals(Instant.MAX, (Instant.MAX - Duration.seconds(4)) + Duration.seconds(5))
+        assertEquals(Instant.MIN, (Instant.MIN + Duration.seconds(10)) - Duration.seconds(12))
     }
 
     @Test
@@ -534,8 +534,8 @@ class InstantRangeTest {
         // Overflowing a LocalDateTime in input
         maxValidInstant.plus(DateTimePeriod(nanoseconds = -1), UTC)
         minValidInstant.plus(DateTimePeriod(nanoseconds = 1), UTC)
-        assertArithmeticFails { (maxValidInstant + 1.nanoseconds).plus(DateTimePeriod(nanoseconds = -2), UTC) }
-        assertArithmeticFails { (minValidInstant - 1.nanoseconds).plus(DateTimePeriod(nanoseconds = 2), UTC) }
+        assertArithmeticFails { (maxValidInstant + Duration.nanoseconds(1)).plus(DateTimePeriod(nanoseconds = -2), UTC) }
+        assertArithmeticFails { (minValidInstant - Duration.nanoseconds(1)).plus(DateTimePeriod(nanoseconds = 2), UTC) }
         // Overflowing a LocalDateTime in result
         assertArithmeticFails { maxValidInstant.plus(DateTimePeriod(nanoseconds = 1), UTC) }
         assertArithmeticFails { minValidInstant.plus(DateTimePeriod(nanoseconds = -1), UTC) }
@@ -557,8 +557,8 @@ class InstantRangeTest {
         // Overflowing a LocalDateTime in input
         maxValidInstant.plus(-1, DateTimeUnit.NANOSECOND, UTC)
         minValidInstant.plus(1, DateTimeUnit.NANOSECOND, UTC)
-        assertArithmeticFails { (maxValidInstant + 1.nanoseconds).plus(-2, DateTimeUnit.NANOSECOND, UTC) }
-        assertArithmeticFails { (minValidInstant - 1.nanoseconds).plus(2, DateTimeUnit.NANOSECOND, UTC) }
+        assertArithmeticFails { (maxValidInstant + Duration.nanoseconds(1)).plus(-2, DateTimeUnit.NANOSECOND, UTC) }
+        assertArithmeticFails { (minValidInstant - Duration.nanoseconds(1)).plus(2, DateTimeUnit.NANOSECOND, UTC) }
         // Overflowing a LocalDateTime in result
         assertArithmeticFails { maxValidInstant.plus(1, DateTimeUnit.NANOSECOND, UTC) }
         assertArithmeticFails { maxValidInstant.plus(1, DateTimeUnit.YEAR, UTC) }
@@ -586,8 +586,8 @@ class InstantRangeTest {
     fun periodUntilOutOfRange() {
         // Instant.periodUntil
         maxValidInstant.periodUntil(maxValidInstant, UTC)
-        assertArithmeticFails { (maxValidInstant + 1.nanoseconds).periodUntil(maxValidInstant, UTC) }
-        assertArithmeticFails { minValidInstant.periodUntil(minValidInstant - 1.nanoseconds, UTC) }
+        assertArithmeticFails { (maxValidInstant + Duration.nanoseconds(1)).periodUntil(maxValidInstant, UTC) }
+        assertArithmeticFails { minValidInstant.periodUntil(minValidInstant - Duration.nanoseconds(1), UTC) }
     }
 
     @Test
@@ -603,11 +603,11 @@ class InstantRangeTest {
     fun unitsUntilOutOfRange() {
         // Instant.until
         // Overflowing a LocalDateTime in input
-        assertArithmeticFails { (maxValidInstant + 1.nanoseconds).until(maxValidInstant, DateTimeUnit.NANOSECOND, UTC) }
-        assertArithmeticFails { maxValidInstant.until(maxValidInstant + 1.nanoseconds, DateTimeUnit.NANOSECOND, UTC) }
+        assertArithmeticFails { (maxValidInstant + Duration.nanoseconds(1)).until(maxValidInstant, DateTimeUnit.NANOSECOND, UTC) }
+        assertArithmeticFails { maxValidInstant.until(maxValidInstant + Duration.nanoseconds(1), DateTimeUnit.NANOSECOND, UTC) }
         // Overloads without a TimeZone should not fail on overflowing a LocalDateTime
-        (maxValidInstant + 1.nanoseconds).until(maxValidInstant, DateTimeUnit.NANOSECOND)
-        maxValidInstant.until(maxValidInstant + 1.nanoseconds, DateTimeUnit.NANOSECOND)
+        (maxValidInstant + Duration.nanoseconds(1)).until(maxValidInstant, DateTimeUnit.NANOSECOND)
+        maxValidInstant.until(maxValidInstant + Duration.nanoseconds(1), DateTimeUnit.NANOSECOND)
     }
 }
 

core/common/test/LocalDateTimeTest.kt

@@ -43,9 +43,9 @@ class LocalDateTimeTest {
         val ldt2 = "2019-10-01T19:50:00.500600".toLocalDateTime()
 
         val diff = with(TimeZone.UTC) { ldt2.toInstant() - ldt1.toInstant() }
-        assertEquals(1.hours + 7.minutes - 15.seconds + 400100.microseconds, diff)
-        assertFailsWith<DateTimeArithmeticException> { (Instant.MAX - 3.days).toLocalDateTime(TimeZone.UTC) }
-        assertFailsWith<DateTimeArithmeticException> { (Instant.MIN + 6.hours).toLocalDateTime(TimeZone.UTC) }
+        assertEquals(with(Duration) { hours(1) + minutes(7) - seconds(15) + microseconds(400100) }, diff)
+        assertFailsWith<DateTimeArithmeticException> { (Instant.MAX - Duration.days(3)).toLocalDateTime(TimeZone.UTC) }
+        assertFailsWith<DateTimeArithmeticException> { (Instant.MIN + Duration.hours(6)).toLocalDateTime(TimeZone.UTC) }
     }
 
     @OptIn(ExperimentalTime::class)
@@ -54,7 +54,7 @@ class LocalDateTimeTest {
         val ldt1 = "2011-03-26T04:00:00".toLocalDateTime()
         val ldt2 = "2011-03-27T04:00:00".toLocalDateTime()
         val diff = with(TimeZone.of("Europe/Moscow")) { ldt2.toInstant() - ldt1.toInstant() }
-        assertEquals(23.hours, diff)
+        assertEquals(Duration.hours(23), diff)
     }
 
     @Test

core/js/src/Instant.kt

@@ -6,18 +6,14 @@
 package kotlinx.datetime
 
 import kotlinx.datetime.internal.JSJoda.ZonedDateTime
-import kotlin.time.Duration
-import kotlin.time.ExperimentalTime
-import kotlin.time.nanoseconds
-import kotlin.time.seconds
 import kotlinx.datetime.internal.JSJoda.Instant as jtInstant
 import kotlinx.datetime.internal.JSJoda.OffsetDateTime as jtOffsetDateTime
 import kotlinx.datetime.internal.JSJoda.Duration as jtDuration
 import kotlinx.datetime.internal.JSJoda.Clock as jtClock
 import kotlinx.datetime.internal.JSJoda.ChronoUnit
 import kotlinx.datetime.serializers.InstantIso8601Serializer
 import kotlinx.serialization.Serializable
-import kotlin.math.truncate
+import kotlin.time.*
 
 @Serializable(with = InstantIso8601Serializer::class)
 @OptIn(ExperimentalTime::class)
@@ -31,14 +27,12 @@ public actual class Instant internal constructor(internal val value: jtInstant)
     public actual fun toEpochMilliseconds(): Long =
             epochSeconds * MILLIS_PER_ONE + nanosecondsOfSecond / NANOS_PER_MILLI
 
-    public actual operator fun plus(duration: Duration): Instant {
-        val addSeconds = truncate(duration.inSeconds)
-        val addNanos = (duration.inNanoseconds % NANOS_PER_ONE).toInt()
+    public actual operator fun plus(duration: Duration): Instant = duration.toComponents { seconds, nanoseconds ->
         return try {
-            Instant(plusFix(addSeconds, addNanos))
+            Instant(plusFix(seconds.toDouble(), nanoseconds))
         } catch (e: Throwable) {
             if (!e.isJodaDateTimeException()) throw e
-            if (addSeconds > 0) MAX else MIN
+            if (seconds > 0) MAX else MIN
         }
     }
 
@@ -52,7 +46,7 @@ public actual class Instant internal constructor(internal val value: jtInstant)
 
     public actual operator fun minus(other: Instant): Duration {
         val diff = jtDuration.between(other.value, this.value)
-        return diff.seconds().toDouble().seconds + diff.nano().toDouble().nanoseconds
+        return Duration.seconds(diff.seconds().toDouble()) + Duration.nanoseconds(diff.nano().toDouble())
     }
 
     public actual override operator fun compareTo(other: Instant): Int = this.value.compareTo(other.value).toInt()
@@ -127,7 +121,7 @@ public actual fun Instant.plus(period: DateTimePeriod, timeZone: TimeZone): Inst
     with(period) {
         thisZdt
                 .run { if (totalMonths != 0) plusMonths(totalMonths) else this }
-                .run { if (days != 0) plusDays(days) as ZonedDateTime else this }
+                .run { if (days != 0) plusDays(days) else this }
                 .run { if (hours != 0) plusHours(hours) else this }
                 .run { if (minutes != 0) plusMinutes(minutes) else this }
                 .run { if (seconds != 0) plusSeconds(seconds) else this }
@@ -152,7 +146,7 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
                     plus(value, unit).value.checkZone(timeZone)
                 }
                 is DateTimeUnit.DateBased.DayBased ->
-                    (thisZdt.plusDays(value.toDouble() * unit.days) as ZonedDateTime).toInstant()
+                    thisZdt.plusDays(value.toDouble() * unit.days).toInstant()
                 is DateTimeUnit.DateBased.MonthBased ->
                     thisZdt.plusMonths(value.toDouble() * unit.months).toInstant()
             }.let(::Instant)
@@ -168,7 +162,7 @@ public actual fun Instant.plus(value: Int, unit: DateTimeUnit, timeZone: TimeZon
                 is DateTimeUnit.TimeBased ->
                     plus(value.toLong(), unit).value.checkZone(timeZone)
                 is DateTimeUnit.DateBased.DayBased ->
-                    (thisZdt.plusDays(value.toDouble() * unit.days) as ZonedDateTime).toInstant()
+                    thisZdt.plusDays(value.toDouble() * unit.days).toInstant()
                 is DateTimeUnit.DateBased.MonthBased ->
                     thisZdt.plusMonths(value.toDouble() * unit.months).toInstant()
             }.let(::Instant)
@@ -201,7 +195,7 @@ public actual fun Instant.periodUntil(other: Instant, timeZone: TimeZone): DateT
     val otherZdt = other.value.atZone(timeZone.zoneId)
 
     val months = thisZdt.until(otherZdt, ChronoUnit.MONTHS).toDouble(); thisZdt = thisZdt.plusMonths(months)
-    val days = thisZdt.until(otherZdt, ChronoUnit.DAYS).toDouble(); thisZdt = thisZdt.plusDays(days) as ZonedDateTime
+    val days = thisZdt.until(otherZdt, ChronoUnit.DAYS).toDouble(); thisZdt = thisZdt.plusDays(days)
     val nanoseconds = thisZdt.until(otherZdt, ChronoUnit.NANOS).toDouble()
 
     buildDateTimePeriod(months.toInt(), days.toInt(), nanoseconds.toLong())

core/jvm/src/Instant.kt

@@ -43,8 +43,8 @@ public actual class Instant internal constructor(internal val value: jtInstant)
     public actual operator fun minus(duration: Duration): Instant = plus(-duration)
 
     public actual operator fun minus(other: Instant): Duration =
-            (this.value.epochSecond - other.value.epochSecond).seconds + // won't overflow given the instant bounds
-            (this.value.nano - other.value.nano).nanoseconds
+            Duration.seconds(this.value.epochSecond - other.value.epochSecond) + // won't overflow given the instant bounds
+            Duration.nanoseconds(this.value.nano - other.value.nano)
 
     public actual override operator fun compareTo(other: Instant): Int = this.value.compareTo(other.value)
 

core/native/src/Instant.kt

@@ -166,8 +166,8 @@ public actual class Instant internal constructor(public actual val epochSeconds:
     public actual operator fun minus(duration: Duration): Instant = plus(-duration)
 
     public actual operator fun minus(other: Instant): Duration =
-        (this.epochSeconds - other.epochSeconds).seconds + // won't overflow given the instant bounds
-            (this.nanosecondsOfSecond - other.nanosecondsOfSecond).nanoseconds
+        Duration.seconds(this.epochSeconds - other.epochSeconds) + // won't overflow given the instant bounds
+        Duration.nanoseconds(this.nanosecondsOfSecond - other.nanosecondsOfSecond)
 
     actual override fun compareTo(other: Instant): Int {
         val s = epochSeconds.compareTo(other.epochSeconds)

core/native/src/TimeZone.kt

@@ -198,7 +198,7 @@ public actual class ZoneOffset internal constructor(internal val offset: ZoneOff
             if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
                 throw IllegalTimeZoneException("Invalid ID for ZoneOffset, non numeric characters found: $offsetId")
             }
-            return (ch1.toInt() - 48) * 10 + (ch2.toInt() - 48)
+            return (ch1 - '0') * 10 + (ch2 - '0')
         }
     }
 }