Enable strict API mode (#100)

Author: dkhalanskyjb

core/build.gradle.kts

@@ -22,6 +22,8 @@ val JDK_8: String by project
 val serializationVersion: String by project
 
 kotlin {
+    explicitApi()
+
     infra {
         target("linuxX64")
         target("mingwX64")

core/common/src/DateTimePeriod.kt

@@ -14,17 +14,17 @@ import kotlinx.serialization.Serializable
 
 @Serializable(with = DateTimePeriodIso8601Serializer::class)
 // TODO: could be error-prone without explicitly named params
-sealed class DateTimePeriod {
+public sealed class DateTimePeriod {
     internal abstract val totalMonths: Int
-    abstract val days: Int
+    public abstract val days: Int
     internal abstract val totalNanoseconds: Long
 
-    val years: Int get() = totalMonths / 12
-    val months: Int get() = totalMonths % 12
-    open val hours: Int get() = (totalNanoseconds / 3_600_000_000_000).toInt()
-    open val minutes: Int get() = ((totalNanoseconds % 3_600_000_000_000) / 60_000_000_000).toInt()
-    open val seconds: Int get() = ((totalNanoseconds % 60_000_000_000) / NANOS_PER_ONE).toInt()
-    open val nanoseconds: Int get() = (totalNanoseconds % NANOS_PER_ONE).toInt()
+    public val years: Int get() = totalMonths / 12
+    public val months: Int get() = totalMonths % 12
+    public open val hours: Int get() = (totalNanoseconds / 3_600_000_000_000).toInt()
+    public open val minutes: Int get() = ((totalNanoseconds % 3_600_000_000_000) / 60_000_000_000).toInt()
+    public open val seconds: Int get() = ((totalNanoseconds % 60_000_000_000) / NANOS_PER_ONE).toInt()
+    public open val nanoseconds: Int get() = (totalNanoseconds % NANOS_PER_ONE).toInt()
 
     private fun allNonpositive() =
         totalMonths <= 0 && days <= 0 && totalNanoseconds <= 0 && (totalMonths or days != 0 || totalNanoseconds != 0L)
@@ -70,8 +70,8 @@ sealed class DateTimePeriod {
         return result
     }
 
-    companion object {
-        fun parse(text: String): DateTimePeriod {
+    public companion object {
+        public fun parse(text: String): DateTimePeriod {
             fun parseException(message: String, position: Int): Nothing =
                 throw DateTimeFormatException("Parse error at char $position: $message")
             val START = 0
@@ -238,20 +238,20 @@ sealed class DateTimePeriod {
 public fun String.toDateTimePeriod(): DateTimePeriod = DateTimePeriod.parse(this)
 
 @Serializable(with = DatePeriodIso8601Serializer::class)
-class DatePeriod internal constructor(
+public class DatePeriod internal constructor(
     internal override val totalMonths: Int,
     override val days: Int,
 ) : DateTimePeriod() {
-    constructor(years: Int = 0, months: Int = 0, days: Int = 0): this(totalMonths(years, months), days)
+    public constructor(years: Int = 0, months: Int = 0, days: Int = 0): this(totalMonths(years, months), days)
     // avoiding excessive computations
     override val hours: Int get() = 0
     override val minutes: Int get() = 0
     override val seconds: Int get() = 0
     override val nanoseconds: Int get() = 0
     internal override val totalNanoseconds: Long get() = 0
 
-    companion object {
-        fun parse(text: String): DatePeriod =
+    public companion object {
+        public fun parse(text: String): DatePeriod =
             when (val period = DateTimePeriod.parse(text)) {
                 is DatePeriod -> period
                 else -> throw DateTimeFormatException("Period $period (parsed from string $text) is not date-based")
@@ -296,7 +296,7 @@ internal fun buildDateTimePeriod(totalMonths: Int = 0, days: Int = 0, totalNanos
     else
         DatePeriod(totalMonths, days)
 
-fun DateTimePeriod(
+public fun DateTimePeriod(
     years: Int = 0,
     months: Int = 0,
     days: Int = 0,
@@ -308,15 +308,15 @@ fun DateTimePeriod(
     totalNanoseconds(hours, minutes, seconds, nanoseconds))
 
 @OptIn(ExperimentalTime::class)
-fun Duration.toDateTimePeriod(): DateTimePeriod = buildDateTimePeriod(totalNanoseconds = toLongNanoseconds())
+public fun Duration.toDateTimePeriod(): DateTimePeriod = buildDateTimePeriod(totalNanoseconds = toLongNanoseconds())
 
-operator fun DateTimePeriod.plus(other: DateTimePeriod): DateTimePeriod = buildDateTimePeriod(
+public operator fun DateTimePeriod.plus(other: DateTimePeriod): DateTimePeriod = buildDateTimePeriod(
     safeAdd(totalMonths, other.totalMonths),
     safeAdd(days, other.days),
     safeAdd(totalNanoseconds, other.totalNanoseconds),
 )
 
-operator fun DatePeriod.plus(other: DatePeriod): DatePeriod = DatePeriod(
+public operator fun DatePeriod.plus(other: DatePeriod): DatePeriod = DatePeriod(
     safeAdd(totalMonths, other.totalMonths),
     safeAdd(days, other.days),
 )

core/common/src/DateTimeUnit.kt

@@ -10,12 +10,12 @@ import kotlinx.serialization.Serializable
 import kotlin.time.*
 
 @Serializable(with = DateTimeUnitSerializer::class)
-sealed class DateTimeUnit {
+public sealed class DateTimeUnit {
 
-    abstract operator fun times(scalar: Int): DateTimeUnit
+    public abstract operator fun times(scalar: Int): DateTimeUnit
 
     @Serializable(with = TimeBasedDateTimeUnitSerializer::class)
-    class TimeBased(val nanoseconds: Long) : DateTimeUnit() {
+    public class TimeBased(public val nanoseconds: Long) : DateTimeUnit() {
         private val unitName: String
         private val unitScale: Long
 
@@ -53,7 +53,7 @@ sealed class DateTimeUnit {
         override fun times(scalar: Int): TimeBased = TimeBased(safeMultiply(nanoseconds, scalar.toLong()))
 
         @ExperimentalTime
-        val duration: Duration
+        public val duration: Duration
             get() = nanoseconds.nanoseconds
 
         override fun equals(other: Any?): Boolean =
@@ -65,10 +65,10 @@ sealed class DateTimeUnit {
     }
 
     @Serializable(with = DateBasedDateTimeUnitSerializer::class)
-    sealed class DateBased : DateTimeUnit() {
+    public sealed class DateBased : DateTimeUnit() {
         // TODO: investigate how to move subclasses up to DateTimeUnit scope
         @Serializable(with = DayBasedDateTimeUnitSerializer::class)
-        class DayBased(val days: Int) : DateBased() {
+        public class DayBased(public val days: Int) : DateBased() {
             init {
                 require(days > 0) { "Unit duration must be positive, but was $days days." }
             }
@@ -86,7 +86,7 @@ sealed class DateTimeUnit {
                 formatToString(days, "DAY")
         }
         @Serializable(with = MonthBasedDateTimeUnitSerializer::class)
-        class MonthBased(val months: Int) : DateBased() {
+        public class MonthBased(public val months: Int) : DateBased() {
             init {
                 require(months > 0) { "Unit duration must be positive, but was $months months." }
             }
@@ -110,18 +110,18 @@ sealed class DateTimeUnit {
     protected fun formatToString(value: Int, unit: String): String = if (value == 1) unit else "$value-$unit"
     protected fun formatToString(value: Long, unit: String): String = if (value == 1L) unit else "$value-$unit"
 
-    companion object {
-        val NANOSECOND = TimeBased(nanoseconds = 1)
-        val MICROSECOND = NANOSECOND * 1000
-        val MILLISECOND = MICROSECOND * 1000
-        val SECOND = MILLISECOND * 1000
-        val MINUTE = SECOND * 60
-        val HOUR = MINUTE * 60
-        val DAY = DateBased.DayBased(days = 1)
-        val WEEK = DAY * 7
-        val MONTH = DateBased.MonthBased(months = 1)
-        val QUARTER = MONTH * 3
-        val YEAR = MONTH * 12
-        val CENTURY = YEAR * 100
+    public companion object {
+        public val NANOSECOND: TimeBased = TimeBased(nanoseconds = 1)
+        public val MICROSECOND: TimeBased = NANOSECOND * 1000
+        public val MILLISECOND: TimeBased = MICROSECOND * 1000
+        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
     }
 }

core/common/src/Exceptions.kt

@@ -20,8 +20,8 @@ public class IllegalTimeZoneException: IllegalArgumentException {
 }
 
 internal class DateTimeFormatException: IllegalArgumentException {
-    public constructor(): super()
-    public constructor(message: String): super(message)
-    public constructor(cause: Throwable): super(cause)
-    public constructor(message: String, cause: Throwable): super(message, cause)
+    constructor(): super()
+    constructor(message: String): super(message)
+    constructor(cause: Throwable): super(cause)
+    constructor(message: String, cause: Throwable): super(message, cause)
 }

core/common/src/Instant.kt

@@ -94,32 +94,32 @@ public expect class Instant : Comparable<Instant> {
     public override fun toString(): String
 
 
-    companion object {
+    public companion object {
         @Deprecated("Use Clock.System.now() instead", ReplaceWith("Clock.System.now()", "kotlinx.datetime.Clock"), level = DeprecationLevel.ERROR)
-        fun now(): Instant
+        public fun now(): Instant
 
         /**
          * Returns an [Instant] that is [epochMilliseconds] number of milliseconds from the epoch instant `1970-01-01T00:00:00Z`.
          *
          * The return value is clamped to the platform-specific boundaries for [Instant] if the result exceeds them.
          */
-        fun fromEpochMilliseconds(epochMilliseconds: Long): Instant
+        public fun fromEpochMilliseconds(epochMilliseconds: Long): Instant
 
         /**
          * Returns an [Instant] that is the [epochSeconds] number of seconds from the epoch instant `1970-01-01T00:00:00Z`
          * and the [nanosecondAdjustment] number of nanoseconds from the whole second.
          *
          * The return value is clamped to the platform-specific boundaries for [Instant] if the result exceeds them.
          */
-        fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Long = 0): Instant
+        public fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Long = 0): Instant
 
         /**
          * Returns an [Instant] that is the [epochSeconds] number of seconds from the epoch instant `1970-01-01T00:00:00Z`
          * and the [nanosecondAdjustment] number of nanoseconds from the whole second.
          *
          * The return value is clamped to the platform-specific boundaries for [Instant] if the result exceeds them.
          */
-        fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant
+        public fun fromEpochSeconds(epochSeconds: Long, nanosecondAdjustment: Int): Instant
 
         /**
          * Parses a string that represents an instant in ISO-8601 format including date and time components and
@@ -132,7 +132,7 @@ public expect class Instant : Comparable<Instant> {
          *
          * @throws IllegalArgumentException if the text cannot be parsed or the boundaries of [Instant] are exceeded.
          */
-        fun parse(isoString: String): Instant
+        public fun parse(isoString: String): Instant
 
 
         /**
@@ -141,27 +141,27 @@ public expect class Instant : Comparable<Instant> {
          * All instants in the range `DISTANT_PAST..DISTANT_FUTURE` can be converted to [LocalDateTime][Instant.toLocalDateTime]
          * without exceptions on all supported platforms.
          */
-        val DISTANT_PAST: Instant // -100001-12-31T23:59:59.999999999Z
+        public val DISTANT_PAST: Instant // -100001-12-31T23:59:59.999999999Z
 
         /**
          * An instant value that is far in the future.
          *
          * All instants in the range `DISTANT_PAST..DISTANT_FUTURE` can be converted to [LocalDateTime][Instant.toLocalDateTime]
          * without exceptions on all supported platforms.
          */
-        val DISTANT_FUTURE: Instant // +100000-01-01T00:00:00Z
+        public val DISTANT_FUTURE: Instant // +100000-01-01T00:00:00Z
 
         internal val MIN: Instant
         internal val MAX: Instant
     }
 }
 
 /** Returns true if the instant is not later than [Instant.DISTANT_PAST]. */
-public val Instant.isDistantPast
+public val Instant.isDistantPast: Boolean
     get() = this <= Instant.DISTANT_PAST
 
 /** Returns true if the instant is not earlier than [Instant.DISTANT_FUTURE]. */
-public val Instant.isDistantFuture
+public val Instant.isDistantFuture: Boolean
     get() = this >= Instant.DISTANT_FUTURE
 
 /**
@@ -408,7 +408,7 @@ public expect fun Instant.plus(value: Long, unit: DateTimeUnit, timeZone: TimeZo
  *
  * @throws DateTimeArithmeticException if this value or the result is too large to fit in [LocalDateTime].
  */
-public fun Instant.minus(value: Long, unit: DateTimeUnit, timeZone: TimeZone) =
+public fun Instant.minus(value: Long, unit: DateTimeUnit, timeZone: TimeZone): Instant =
     if (value != Long.MIN_VALUE) {
         plus(-value, unit, timeZone)
     } else {

core/common/src/LocalDate.kt

@@ -10,7 +10,7 @@ import kotlinx.serialization.Serializable
 
 @Serializable(with = LocalDateIso8601Serializer::class)
 public expect class LocalDate : Comparable<LocalDate> {
-    companion object {
+    public companion object {
         /**
          * Parses a string that represents a date in ISO-8601 format
          * and returns the parsed [LocalDate] value.
@@ -112,7 +112,7 @@ public fun LocalDate.atTime(hour: Int, minute: Int, second: Int = 0, nanosecond:
  * @throws DateTimeArithmeticException if this value or the results of intermediate computations are too large to fit in
  * [LocalDate].
  */
-expect operator fun LocalDate.plus(period: DatePeriod): LocalDate
+public expect operator fun LocalDate.plus(period: DatePeriod): LocalDate
 
 /**
  * Returns a date that is the result of subtracting components of [DatePeriod] from this date. The components are
@@ -145,7 +145,7 @@ public operator fun LocalDate.minus(period: DatePeriod): LocalDate =
  *
  * @see LocalDate.minus
  */
-expect fun LocalDate.periodUntil(other: LocalDate): DatePeriod
+public expect fun LocalDate.periodUntil(other: LocalDate): DatePeriod
 
 /**
  * Returns a [DatePeriod] representing the difference between [other] and `this` dates.
@@ -161,7 +161,7 @@ expect fun LocalDate.periodUntil(other: LocalDate): DatePeriod
  *
  * @see LocalDate.periodUntil
  */
-operator fun LocalDate.minus(other: LocalDate): DatePeriod = other.periodUntil(this)
+public operator fun LocalDate.minus(other: LocalDate): DatePeriod = other.periodUntil(this)
 
 /**
  * Returns the whole number of the specified date [units][unit] between `this` and [other] dates.

core/common/src/LocalDateTime.kt

@@ -10,7 +10,7 @@ import kotlinx.serialization.Serializable
 
 @Serializable(with = LocalDateTimeIso8601Serializer::class)
 public expect class LocalDateTime : Comparable<LocalDateTime> {
-    companion object {
+    public companion object {
 
         /**
          * Parses a string that represents a date/time value in ISO-8601 format including date and time components

core/common/src/TimeZone.kt

@@ -21,18 +21,18 @@ public expect open class TimeZone {
      */
     public val id: String
 
-    companion object {
+    public companion object {
         /**
          * Queries the current system time zone.
          *
          * If the current system time zone changes, this function can reflect this change on the next invocation.
          */
-        fun currentSystemDefault(): TimeZone
+        public fun currentSystemDefault(): TimeZone
 
         /**
          * Returns the time zone with the fixed UTC+0 offset.
          */
-        val UTC: TimeZone
+        public val UTC: TimeZone
 
         /**
          * Returns the time zone identified by the provided [zoneId].
@@ -48,12 +48,12 @@ public expect open class TimeZone {
          * @throws IllegalTimeZoneException if [zoneId] has an invalid format or a time-zone with the name [zoneId]
          * is not found.
          */
-        fun of(zoneId: String): TimeZone
+        public fun of(zoneId: String): TimeZone
 
         /**
          * Queries the set of identifiers of time zones available in the system.
          */
-        val availableZoneIds: Set<String>
+        public val availableZoneIds: Set<String>
     }
 
     /**
@@ -87,7 +87,7 @@ public expect open class TimeZone {
 
 @Serializable(with = ZoneOffsetSerializer::class)
 public expect class ZoneOffset : TimeZone {
-    val totalSeconds: Int
+    public val totalSeconds: Int
 }
 
 /**