Merge branch 'master' into master

lion7 · web-flow · commit 7ae06911554f · 2021-11-06T09:47:32.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## 0.3.1
+
+#### Fixes
+
+- Fixed a crash in desugared code on Android when trying to construct time zones with some specific identifiers ([149](https://github.com/Kotlin/kotlinx-datetime/issues/149))
+
+## 0.3.0
+
+#### Features
+
+- Added `iosSimulatorArm64`, `watchosSimulatorArm64`, `tvosSimulatorArm64`, `macosArm64` target support ([141](https://github.com/Kotlin/kotlinx-datetime/issues/141), [144](https://github.com/Kotlin/kotlinx-datetime/issues/144)).
+
+#### Changes
+
+- `ZoneOffset` was replaced by two other classes: `FixedOffsetTimeZone`, which represents a time zone with a fixed offset, and `UtcOffset`, which represents just the UTC offset ([PR#125](https://github.com/Kotlin/kotlinx-datetime/pull/125)).
+- The `DayBased` and `MonthBased` subclasses of `DateTimeUnit.DateBased` are now accessed as `DateTimeUnit.DayBased` and `DateTimeUnit.MonthBased` as opposed to `DateTimeUnit.DateBased.DayBased` and `DateTimeUnit.DateBased.MonthBased` respectively ([PR#131](https://github.com/Kotlin/kotlinx-datetime/pull/131)).
+
 ## 0.2.1
 
 #### Fixes
diff --git a/README.md b/README.md
@@ -36,13 +36,14 @@ The library provides the basic set of types for working with date and time:
 - `Clock` to obtain the current instant;
 - `LocalDateTime` to represent date and time components without a reference to the particular time zone; 
 - `LocalDate` to represent the components of date only;
-- `TimeZone` and `ZoneOffset` provide time zone information to convert between `Instant` and `LocalDateTime`;
+- `TimeZone` and `FixedOffsetTimeZone` provide time zone information to convert between `Instant` and `LocalDateTime`;
 - `Month` and `DayOfWeek` enums;
 - `DateTimePeriod` to represent a difference between two instants decomposed into date and time units;
 - `DatePeriod` is a subclass of `DateTimePeriod` with zero time components,
 it represents a difference between two LocalDate values decomposed into date units.
 - `DateTimeUnit` provides a set of predefined date and time units to use in arithmetic operations on `Instant` and `LocalDate`. 
-  
+- `UtcOffset` represents the amount of time the local date/time at a particular time zone differs from the date/time at UTC.
+
 ### Type use-cases
 
 Here is some basic advice on how to choose which of the date-carrying types to use in what cases:
@@ -295,7 +296,7 @@ kotlin {
     sourceSets {
         commonMain {
              dependencies {
-                 implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.2.1")
+                 implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.1")
              }
         }
     }
@@ -306,7 +307,7 @@ kotlin {
 
 ```groovy
 dependencies {
-    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.2.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.1")
 }
 ```
 
@@ -346,7 +347,7 @@ Add a dependency to the `<dependencies>` element. Note that you need to use the
 <dependency>
     <groupId>org.jetbrains.kotlinx</groupId>
     <artifactId>kotlinx-datetime-jvm</artifactId>
-    <version>0.2.1</version>
+    <version>0.3.1</version>
 </dependency>
 ```
 
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
@@ -31,15 +31,19 @@ kotlin {
 
         common("darwin") {
             target("macosX64")
+            target("macosArm64")
             target("iosX64")
             target("iosArm64")
             target("iosArm32")
+            target("iosSimulatorArm64")
             target("watchosArm32")
             target("watchosArm64")
             target("watchosX86")
             target("watchosX64")
+            target("watchosSimulatorArm64")
             target("tvosArm64")
             target("tvosX64")
+            target("tvosSimulatorArm64")
         }
     }
 
diff --git a/core/common/src/DateTimeUnit.kt b/core/common/src/DateTimeUnit.kt
@@ -66,44 +66,51 @@ public sealed class DateTimeUnit {
 
     @Serializable(with = DateBasedDateTimeUnitSerializer::class)
     public sealed class DateBased : DateTimeUnit() {
-        // TODO: investigate how to move subclasses up to DateTimeUnit scope
-        @Serializable(with = DayBasedDateTimeUnitSerializer::class)
-        public class DayBased(public val days: Int) : DateBased() {
-            init {
-                require(days > 0) { "Unit duration must be positive, but was $days days." }
-            }
+        @Suppress("TOPLEVEL_TYPEALIASES_ONLY")
+        @Deprecated("Use DateTimeUnit.DayBased", ReplaceWith("DateTimeUnit.DayBased", "kotlinx.datetime.DateTimeUnit"))
+        public typealias DayBased = DateTimeUnit.DayBased
+        @Suppress("TOPLEVEL_TYPEALIASES_ONLY")
+        @Deprecated("Use DateTimeUnit.MonthBased", ReplaceWith("DateTimeUnit.MonthBased", "kotlinx.datetime.DateTimeUnit"))
+        public typealias MonthBased = DateTimeUnit.MonthBased
+    }
+
+    @Serializable(with = DayBasedDateTimeUnitSerializer::class)
+    public class DayBased(public val days: Int) : DateBased() {
+        init {
+            require(days > 0) { "Unit duration must be positive, but was $days days." }
+        }
+
+        override fun times(scalar: Int): DateTimeUnit.DayBased = DateTimeUnit.DayBased(safeMultiply(days, scalar))
 
-            override fun times(scalar: Int): DayBased = DayBased(safeMultiply(days, scalar))
+        override fun equals(other: Any?): Boolean =
+            this === other || (other is DateTimeUnit.DayBased && this.days == other.days)
 
-            override fun equals(other: Any?): Boolean =
-                    this === other || (other is DayBased && this.days == other.days)
+        override fun hashCode(): Int = days xor 0x10000
 
-            override fun hashCode(): Int = days xor 0x10000
+        override fun toString(): String = if (days % 7 == 0)
+            formatToString(days / 7, "WEEK")
+        else
+            formatToString(days, "DAY")
+    }
 
-            override fun toString(): String = if (days % 7 == 0)
-                formatToString(days / 7, "WEEK")
-            else
-                formatToString(days, "DAY")
+    @Serializable(with = MonthBasedDateTimeUnitSerializer::class)
+    public class MonthBased(public val months: Int) : DateBased() {
+        init {
+            require(months > 0) { "Unit duration must be positive, but was $months months." }
         }
-        @Serializable(with = MonthBasedDateTimeUnitSerializer::class)
-        public class MonthBased(public val months: Int) : DateBased() {
-            init {
-                require(months > 0) { "Unit duration must be positive, but was $months months." }
-            }
 
-            override fun times(scalar: Int): MonthBased = MonthBased(safeMultiply(months, scalar))
+        override fun times(scalar: Int): DateTimeUnit.MonthBased = DateTimeUnit.MonthBased(safeMultiply(months, scalar))
 
-            override fun equals(other: Any?): Boolean =
-                    this === other || (other is MonthBased && this.months == other.months)
+        override fun equals(other: Any?): Boolean =
+            this === other || (other is DateTimeUnit.MonthBased && this.months == other.months)
 
-            override fun hashCode(): Int = months xor 0x20000
+        override fun hashCode(): Int = months xor 0x20000
 
-            override fun toString(): String = when {
-                months % 12_00 == 0 -> formatToString(months / 12_00, "CENTURY")
-                months % 12 == 0 -> formatToString(months / 12, "YEAR")
-                months % 3 == 0 -> formatToString(months / 3, "QUARTER")
-                else -> formatToString(months, "MONTH")
-            }
+        override fun toString(): String = when {
+            months % 12_00 == 0 -> formatToString(months / 12_00, "CENTURY")
+            months % 12 == 0 -> formatToString(months / 12, "YEAR")
+            months % 3 == 0 -> formatToString(months / 3, "QUARTER")
+            else -> formatToString(months, "MONTH")
         }
     }
 
@@ -117,11 +124,11 @@ public sealed class DateTimeUnit {
         public val SECOND: TimeBased = MILLISECOND * 1000
         public val MINUTE: TimeBased = SECOND * 60
         public val HOUR: TimeBased = MINUTE * 60
-        public val DAY: DateBased.DayBased = DateBased.DayBased(days = 1)
-        public val WEEK: DateBased.DayBased = DAY * 7
-        public val MONTH: DateBased.MonthBased = DateBased.MonthBased(months = 1)
-        public val QUARTER: DateBased.MonthBased = MONTH * 3
-        public val YEAR: DateBased.MonthBased = MONTH * 12
-        public val CENTURY: DateBased.MonthBased = YEAR * 100
+        public val DAY: DayBased = DayBased(days = 1)
+        public val WEEK: DayBased = DAY * 7
+        public val MONTH: MonthBased = MonthBased(months = 1)
+        public val QUARTER: MonthBased = MONTH * 3
+        public val YEAR: MonthBased = MONTH * 12
+        public val CENTURY: MonthBased = YEAR * 100
     }
 }
diff --git a/core/common/src/serializers/DateTimeUnitSerializers.kt b/core/common/src/serializers/DateTimeUnitSerializers.kt
@@ -53,21 +53,21 @@ public object TimeBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.TimeBase
     }
 }
 
-public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased.DayBased> {
+public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DayBased> {
 
     override val descriptor: SerialDescriptor = buildClassSerialDescriptor("DayBased") {
         element<Int>("days")
     }
 
-    override fun serialize(encoder: Encoder, value: DateTimeUnit.DateBased.DayBased) {
+    override fun serialize(encoder: Encoder, value: DateTimeUnit.DayBased) {
         encoder.encodeStructure(descriptor) {
             encodeIntElement(descriptor, 0, value.days)
         }
     }
 
     @ExperimentalSerializationApi
     @Suppress("INVISIBLE_MEMBER") // to be able to throw `MissingFieldException`
-    override fun deserialize(decoder: Decoder): DateTimeUnit.DateBased.DayBased {
+    override fun deserialize(decoder: Decoder): DateTimeUnit.DayBased {
         var seen = false
         var days = 0
         decoder.decodeStructure(descriptor) {
@@ -88,25 +88,25 @@ public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased
             }
         }
         if (!seen) throw MissingFieldException("days")
-        return DateTimeUnit.DateBased.DayBased(days)
+        return DateTimeUnit.DayBased(days)
     }
 }
 
-public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased.MonthBased> {
+public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.MonthBased> {
 
     override val descriptor: SerialDescriptor = buildClassSerialDescriptor("MonthBased") {
         element<Int>("months")
     }
 
-    override fun serialize(encoder: Encoder, value: DateTimeUnit.DateBased.MonthBased) {
+    override fun serialize(encoder: Encoder, value: DateTimeUnit.MonthBased) {
         encoder.encodeStructure(descriptor) {
             encodeIntElement(descriptor, 0, value.months)
         }
     }
 
     @ExperimentalSerializationApi
     @Suppress("INVISIBLE_MEMBER") // to be able to throw `MissingFieldException`
-    override fun deserialize(decoder: Decoder): DateTimeUnit.DateBased.MonthBased {
+    override fun deserialize(decoder: Decoder): DateTimeUnit.MonthBased {
         var seen = false
         var months = 0
         decoder.decodeStructure(descriptor) {
@@ -127,7 +127,7 @@ public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBas
             }
         }
         if (!seen) throw MissingFieldException("months")
-        return DateTimeUnit.DateBased.MonthBased(months)
+        return DateTimeUnit.MonthBased(months)
     }
 }
 
@@ -136,7 +136,7 @@ public object DateBasedDateTimeUnitSerializer: AbstractPolymorphicSerializer<Dat
 
     private val impl = SealedClassSerializer("kotlinx.datetime.DateTimeUnit.DateBased",
         DateTimeUnit.DateBased::class,
-        arrayOf(DateTimeUnit.DateBased.DayBased::class, DateTimeUnit.DateBased.MonthBased::class),
+        arrayOf(DateTimeUnit.DayBased::class, DateTimeUnit.MonthBased::class),
         arrayOf(DayBasedDateTimeUnitSerializer, MonthBasedDateTimeUnitSerializer))
 
     @InternalSerializationApi
@@ -164,7 +164,7 @@ public object DateTimeUnitSerializer: AbstractPolymorphicSerializer<DateTimeUnit
 
     private val impl = SealedClassSerializer("kotlinx.datetime.DateTimeUnit",
         DateTimeUnit::class,
-        arrayOf(DateTimeUnit.DateBased.DayBased::class, DateTimeUnit.DateBased.MonthBased::class, DateTimeUnit.TimeBased::class),
+        arrayOf(DateTimeUnit.DayBased::class, DateTimeUnit.MonthBased::class, DateTimeUnit.TimeBased::class),
         arrayOf(DayBasedDateTimeUnitSerializer, MonthBasedDateTimeUnitSerializer, TimeBasedDateTimeUnitSerializer))
 
     @InternalSerializationApi
diff --git a/core/js/src/Instant.kt b/core/js/src/Instant.kt
@@ -145,9 +145,9 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
                 is DateTimeUnit.TimeBased -> {
                     plus(value, unit).value.checkZone(timeZone)
                 }
-                is DateTimeUnit.DateBased.DayBased ->
+                is DateTimeUnit.DayBased ->
                     thisZdt.plusDays(value.toDouble() * unit.days).toInstant()
-                is DateTimeUnit.DateBased.MonthBased ->
+                is DateTimeUnit.MonthBased ->
                     thisZdt.plusMonths(value.toDouble() * unit.months).toInstant()
             }.let(::Instant)
         } catch (e: Throwable) {
@@ -161,9 +161,9 @@ public actual fun Instant.plus(value: Int, unit: DateTimeUnit, timeZone: TimeZon
             when (unit) {
                 is DateTimeUnit.TimeBased ->
                     plus(value.toLong(), unit).value.checkZone(timeZone)
-                is DateTimeUnit.DateBased.DayBased ->
+                is DateTimeUnit.DayBased ->
                     thisZdt.plusDays(value.toDouble() * unit.days).toInstant()
-                is DateTimeUnit.DateBased.MonthBased ->
+                is DateTimeUnit.MonthBased ->
                     thisZdt.plusMonths(value.toDouble() * unit.months).toInstant()
             }.let(::Instant)
         } catch (e: Throwable) {
@@ -208,8 +208,8 @@ public actual fun Instant.until(other: Instant, unit: DateTimeUnit, timeZone: Ti
     val otherZdt = other.atZone(timeZone)
     when(unit) {
         is DateTimeUnit.TimeBased -> until(other, unit)
-        is DateTimeUnit.DateBased.DayBased -> (thisZdt.until(otherZdt, ChronoUnit.DAYS).toDouble() / unit.days).toLong()
-        is DateTimeUnit.DateBased.MonthBased -> (thisZdt.until(otherZdt, ChronoUnit.MONTHS).toDouble() / unit.months).toLong()
+        is DateTimeUnit.DayBased -> (thisZdt.until(otherZdt, ChronoUnit.DAYS).toDouble() / unit.days).toLong()
+        is DateTimeUnit.MonthBased -> (thisZdt.until(otherZdt, ChronoUnit.MONTHS).toDouble() / unit.months).toLong()
     }
 } catch (e: ArithmeticException) {
     if (this < other) Long.MAX_VALUE else Long.MIN_VALUE
diff --git a/core/js/src/LocalDate.kt b/core/js/src/LocalDate.kt
@@ -59,8 +59,8 @@ public actual fun LocalDate.plus(value: Long, unit: DateTimeUnit.DateBased): Loc
 private fun LocalDate.plusNumber(value: Number, unit: DateTimeUnit.DateBased): LocalDate =
         try {
             when (unit) {
-                is DateTimeUnit.DateBased.DayBased -> this.value.plusDays(value.toDouble() * unit.days)
-                is DateTimeUnit.DateBased.MonthBased -> this.value.plusMonths(value.toDouble() * unit.months)
+                is DateTimeUnit.DayBased -> this.value.plusDays(value.toDouble() * unit.days)
+                is DateTimeUnit.MonthBased -> this.value.plusMonths(value.toDouble() * unit.months)
             }.let(::LocalDate)
         } catch (e: Throwable) {
             if (!e.isJodaDateTimeException() && !e.isJodaArithmeticException()) throw e
@@ -92,8 +92,8 @@ public actual fun LocalDate.periodUntil(other: LocalDate): DatePeriod {
 }
 
 public actual fun LocalDate.until(other: LocalDate, unit: DateTimeUnit.DateBased): Int = when(unit) {
-    is DateTimeUnit.DateBased.MonthBased -> monthsUntil(other) / unit.months
-    is DateTimeUnit.DateBased.DayBased -> daysUntil(other) / unit.days
+    is DateTimeUnit.MonthBased -> monthsUntil(other) / unit.months
+    is DateTimeUnit.DayBased -> daysUntil(other) / unit.days
 }
 
 public actual fun LocalDate.daysUntil(other: LocalDate): Int =
diff --git a/core/jvm/src/Instant.kt b/core/jvm/src/Instant.kt
@@ -133,9 +133,9 @@ public actual fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
             when (unit) {
                 is DateTimeUnit.TimeBased ->
                     plus(value, unit).value.also { it.atZone(timeZone.zoneId) }
-                is DateTimeUnit.DateBased.DayBased ->
+                is DateTimeUnit.DayBased ->
                     thisZdt.plusDays(safeMultiply(value, unit.days.toLong())).toInstant()
-                is DateTimeUnit.DateBased.MonthBased ->
+                is DateTimeUnit.MonthBased ->
                     thisZdt.plusMonths(safeMultiply(value, unit.months.toLong())).toInstant()
             }.let(::Instant)
         } catch (e: Exception) {
@@ -173,8 +173,8 @@ public actual fun Instant.until(other: Instant, unit: DateTimeUnit, timeZone: Ti
     val otherZdt = other.atZone(timeZone)
     when(unit) {
         is DateTimeUnit.TimeBased -> until(other, unit)
-        is DateTimeUnit.DateBased.DayBased -> thisZdt.until(otherZdt, ChronoUnit.DAYS) / unit.days
-        is DateTimeUnit.DateBased.MonthBased -> thisZdt.until(otherZdt, ChronoUnit.MONTHS) / unit.months
+        is DateTimeUnit.DayBased -> thisZdt.until(otherZdt, ChronoUnit.DAYS) / unit.days
+        is DateTimeUnit.MonthBased -> thisZdt.until(otherZdt, ChronoUnit.MONTHS) / unit.months
     }
 } catch (e: DateTimeException) {
     throw DateTimeArithmeticException(e)
diff --git a/core/jvm/src/LocalDate.kt b/core/jvm/src/LocalDate.kt
@@ -63,11 +63,11 @@ public actual fun LocalDate.minus(value: Int, unit: DateTimeUnit.DateBased): Loc
 public actual fun LocalDate.plus(value: Long, unit: DateTimeUnit.DateBased): LocalDate =
         try {
             when (unit) {
-                is DateTimeUnit.DateBased.DayBased -> {
+                is DateTimeUnit.DayBased -> {
                     val addDays: Long = safeMultiply(value, unit.days.toLong())
                     ofEpochDayChecked(safeAdd(this.value.toEpochDay(), addDays))
                 }
-                is DateTimeUnit.DateBased.MonthBased ->
+                is DateTimeUnit.MonthBased ->
                     this.value.plusMonths(safeMultiply(value, unit.months.toLong()))
             }.let(::LocalDate)
         } catch (e: Exception) {
@@ -109,8 +109,8 @@ public actual fun LocalDate.periodUntil(other: LocalDate): DatePeriod {
 }
 
 public actual fun LocalDate.until(other: LocalDate, unit: DateTimeUnit.DateBased): Int = when(unit) {
-    is DateTimeUnit.DateBased.MonthBased -> (this.value.until(other.value, ChronoUnit.MONTHS) / unit.months).clampToInt()
-    is DateTimeUnit.DateBased.DayBased -> (this.value.until(other.value, ChronoUnit.DAYS) / unit.days).clampToInt()
+    is DateTimeUnit.MonthBased -> (this.value.until(other.value, ChronoUnit.MONTHS) / unit.months).clampToInt()
+    is DateTimeUnit.DayBased -> (this.value.until(other.value, ChronoUnit.DAYS) / unit.days).clampToInt()
 }
 
 public actual fun LocalDate.daysUntil(other: LocalDate): Int =
diff --git a/core/jvm/src/TimeZoneJvm.kt b/core/jvm/src/TimeZoneJvm.kt
@@ -44,7 +44,7 @@ public actual open class TimeZone internal constructor(internal val zoneId: Zone
         internal fun ofZone(zoneId: ZoneId): TimeZone = when {
             zoneId is jtZoneOffset ->
                 FixedOffsetTimeZone(UtcOffset(zoneId))
-            zoneId.rules.isFixedOffset ->
+            zoneId.isFixedOffset ->
                 FixedOffsetTimeZone(UtcOffset(zoneId.normalized() as jtZoneOffset), zoneId)
             else ->
                 TimeZone(zoneId)
@@ -54,6 +54,15 @@ public actual open class TimeZone internal constructor(internal val zoneId: Zone
     }
 }
 
+// Workaround for https://issuetracker.google.com/issues/203956057
+private val ZoneId.isFixedOffset: Boolean
+    get() = try {
+        // On older Android versions, this can throw even though it shouldn't
+        rules.isFixedOffset
+    } catch (e: ArrayIndexOutOfBoundsException) {
+        false // Happens for America/Costa_Rica, Africa/Cairo, Egypt
+    }
+
 @Serializable(with = FixedOffsetTimeZoneSerializer::class)
 public actual class FixedOffsetTimeZone
 internal constructor(public actual val offset: UtcOffset, zoneId: ZoneId): TimeZone(zoneId) {
diff --git a/core/native/src/LocalDate.kt b/core/native/src/LocalDate.kt
diff --git a/core/native/src/LocalDateTime.kt b/core/native/src/LocalDateTime.kt
diff --git a/gradle.properties b/gradle.properties
diff --git a/serialization/build.gradle.kts b/serialization/build.gradle.kts
diff --git a/serialization/common/test/DateTimeUnitSerializationTest.kt b/serialization/common/test/DateTimeUnitSerializationTest.kt

Original file line number	Diff line number	Diff line change
`@@ -53,21 +53,21 @@ public object TimeBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.TimeBase`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased.DayBased> {`
	`56`	`+public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DayBased> {`
`57`	`57`
`58`	`58`	`override val descriptor: SerialDescriptor = buildClassSerialDescriptor("DayBased") {`
`59`	`59`	`element<Int>("days")`
`60`	`60`	`}`
`61`	`61`
`62`		`- override fun serialize(encoder: Encoder, value: DateTimeUnit.DateBased.DayBased) {`
	`62`	`+ override fun serialize(encoder: Encoder, value: DateTimeUnit.DayBased) {`
`63`	`63`	`encoder.encodeStructure(descriptor) {`
`64`	`64`	`encodeIntElement(descriptor, 0, value.days)`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`@ExperimentalSerializationApi`
`69`	`69`	@Suppress("INVISIBLE_MEMBER") // to be able to throw `MissingFieldException`
`70`		`- override fun deserialize(decoder: Decoder): DateTimeUnit.DateBased.DayBased {`
	`70`	`+ override fun deserialize(decoder: Decoder): DateTimeUnit.DayBased {`
`71`	`71`	`var seen = false`
`72`	`72`	`var days = 0`
`73`	`73`	`decoder.decodeStructure(descriptor) {`
`@@ -88,25 +88,25 @@ public object DayBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`if (!seen) throw MissingFieldException("days")`
`91`		`- return DateTimeUnit.DateBased.DayBased(days)`
	`91`	`+ return DateTimeUnit.DayBased(days)`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`-public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBased.MonthBased> {`
	`95`	`+public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.MonthBased> {`
`96`	`96`
`97`	`97`	`override val descriptor: SerialDescriptor = buildClassSerialDescriptor("MonthBased") {`
`98`	`98`	`element<Int>("months")`
`99`	`99`	`}`
`100`	`100`
`101`		`- override fun serialize(encoder: Encoder, value: DateTimeUnit.DateBased.MonthBased) {`
	`101`	`+ override fun serialize(encoder: Encoder, value: DateTimeUnit.MonthBased) {`
`102`	`102`	`encoder.encodeStructure(descriptor) {`
`103`	`103`	`encodeIntElement(descriptor, 0, value.months)`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`@ExperimentalSerializationApi`
`108`	`108`	@Suppress("INVISIBLE_MEMBER") // to be able to throw `MissingFieldException`
`109`		`- override fun deserialize(decoder: Decoder): DateTimeUnit.DateBased.MonthBased {`
	`109`	`+ override fun deserialize(decoder: Decoder): DateTimeUnit.MonthBased {`
`110`	`110`	`var seen = false`
`111`	`111`	`var months = 0`
`112`	`112`	`decoder.decodeStructure(descriptor) {`
`@@ -127,7 +127,7 @@ public object MonthBasedDateTimeUnitSerializer: KSerializer<DateTimeUnit.DateBas`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`if (!seen) throw MissingFieldException("months")`
`130`		`- return DateTimeUnit.DateBased.MonthBased(months)`
	`130`	`+ return DateTimeUnit.MonthBased(months)`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`@@ -136,7 +136,7 @@ public object DateBasedDateTimeUnitSerializer: AbstractPolymorphicSerializer<Dat`
`136`	`136`
`137`	`137`	`private val impl = SealedClassSerializer("kotlinx.datetime.DateTimeUnit.DateBased",`
`138`	`138`	`DateTimeUnit.DateBased::class,`
`139`		`- arrayOf(DateTimeUnit.DateBased.DayBased::class, DateTimeUnit.DateBased.MonthBased::class),`
	`139`	`+ arrayOf(DateTimeUnit.DayBased::class, DateTimeUnit.MonthBased::class),`
`140`	`140`	`arrayOf(DayBasedDateTimeUnitSerializer, MonthBasedDateTimeUnitSerializer))`
`141`	`141`
`142`	`142`	`@InternalSerializationApi`
`@@ -164,7 +164,7 @@ public object DateTimeUnitSerializer: AbstractPolymorphicSerializer<DateTimeUnit`
`164`	`164`
`165`	`165`	`private val impl = SealedClassSerializer("kotlinx.datetime.DateTimeUnit",`
`166`	`166`	`DateTimeUnit::class,`
`167`		`- arrayOf(DateTimeUnit.DateBased.DayBased::class, DateTimeUnit.DateBased.MonthBased::class, DateTimeUnit.TimeBased::class),`
	`167`	`+ arrayOf(DateTimeUnit.DayBased::class, DateTimeUnit.MonthBased::class, DateTimeUnit.TimeBased::class),`
`168`	`168`	`arrayOf(DayBasedDateTimeUnitSerializer, MonthBasedDateTimeUnitSerializer, TimeBasedDateTimeUnitSerializer))`
`169`	`169`
`170`	`170`	`@InternalSerializationApi`